@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/src/modules/workflows/api/definitions/route.ts

@@ -6,6 +6,7 @@
  * - POST /api/workflows/definitions - Create workflow definition
  */
 
+import { randomUUID } from 'node:crypto'
 import { NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
@@ -16,11 +17,23 @@ import { resolveOrganizationScopeFilter } from '@open-mercato/core/modules/direc
 import { WorkflowDefinition } from '../../data/entities'
 import {
   createWorkflowDefinitionInputSchema,
+  createWorkflowDefinitionInputCheckedSchema,
   type CreateWorkflowDefinitionApiInput,
 } from '../../data/validators'
 import { serializeWorkflowDefinition, serializeCodeWorkflowDefinition } from './serialize'
+import {
+  workflowDefinitionListResponseSchema,
+  workflowDefinitionMutationResponseSchema,
+  workflowErrorSchema,
+} from '../openapi'
 import { invalidateTriggerCache } from '../../lib/event-trigger-service'
+import { normalizeDefinitionValidationIssues } from '../../lib/definition-error-body'
 import { getAllCodeWorkflows } from '../../lib/code-registry'
+import {
+  authorizeWorkflowGrantChange,
+  normalizeGrantedFeatures,
+  syncWorkflowDefinitionPrincipal,
+} from '../../lib/definition-grant'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('workflows')
@@ -30,7 +43,10 @@ export const metadata = {
   requireFeatures: ['workflows.definitions.view'],
 }
 
+// Post-versioning the unique constraint is (workflow_id, version, tenant_id);
+// the legacy name is still matched so the check survives a partially-migrated DB.
 const WORKFLOW_ID_TENANT_UNIQUE_CONSTRAINT = 'workflow_definitions_workflow_id_tenant_id_unique'
+const WORKFLOW_ID_VERSION_TENANT_UNIQUE_CONSTRAINT = 'workflow_definitions_workflow_id_version_tenant_id_unique'
 
 function isWorkflowIdUniqueConstraintError(error: unknown): boolean {
   if (!error || typeof error !== 'object') {
@@ -43,15 +59,15 @@ function isWorkflowIdUniqueConstraintError(error: unknown): boolean {
   const message = typeof value.message === 'string' ? value.message : ''
   const detail = typeof value.detail === 'string' ? value.detail : ''
 
-  if (constraint === WORKFLOW_ID_TENANT_UNIQUE_CONSTRAINT) {
+  if (constraint === WORKFLOW_ID_TENANT_UNIQUE_CONSTRAINT || constraint === WORKFLOW_ID_VERSION_TENANT_UNIQUE_CONSTRAINT) {
     return true
   }
 
-  if (code === '23505' && detail.includes('(workflow_id, tenant_id)')) {
+  if (code === '23505' && (detail.includes('(workflow_id, tenant_id)') || detail.includes('(workflow_id, version, tenant_id)'))) {
     return true
   }
 
-  return message.includes(WORKFLOW_ID_TENANT_UNIQUE_CONSTRAINT)
+  return message.includes(WORKFLOW_ID_TENANT_UNIQUE_CONSTRAINT) || message.includes(WORKFLOW_ID_VERSION_TENANT_UNIQUE_CONSTRAINT)
 }
 
 /**
@@ -77,6 +93,10 @@ export async function GET(request: NextRequest) {
     const enabled = searchParams.get('enabled')
     const workflowId = searchParams.get('workflowId')
     const search = searchParams.get('search')
+    const kind = searchParams.get('kind')
+    const lifecycle = searchParams.get('lifecycle')
+    const versionParam = searchParams.get('version')
+    const version = versionParam !== null && /^\d+$/.test(versionParam) ? parseInt(versionParam, 10) : null
     const limit = parseInt(searchParams.get('limit') || '50')
     const offset = parseInt(searchParams.get('offset') || '0')
 
@@ -95,6 +115,18 @@ export async function GET(request: NextRequest) {
       where.workflowId = workflowId
     }
 
+    if (kind) {
+      where.kind = kind
+    }
+
+    if (lifecycle) {
+      where.lifecycle = lifecycle
+    }
+
+    if (version !== null) {
+      where.version = version
+    }
+
     if (search) {
       where.$or = [
         { workflowId: { $ilike: `%${escapeLikePattern(search)}%` } },
@@ -122,6 +154,10 @@ export async function GET(request: NextRequest) {
     const codeOnly = getAllCodeWorkflows()
       .filter((cw) => !shadowed.has(cw.workflowId))
       .filter((cw) => {
+        // Code-based definitions are always kind=workflow / lifecycle=published.
+        if (kind && kind !== 'workflow') return false
+        if (lifecycle && lifecycle !== 'published') return false
+        if (version !== null && cw.version !== version) return false
         if (searchLower) {
           const matches =
             cw.workflowId.toLowerCase().includes(searchLower) ||
@@ -213,12 +249,12 @@ export async function POST(request: NextRequest) {
     const body = await request.json()
 
     // Validate input
-    const validation = createWorkflowDefinitionInputSchema.safeParse(body)
+    const validation = createWorkflowDefinitionInputCheckedSchema.safeParse(body)
     if (!validation.success) {
       return NextResponse.json(
         {
           error: 'Validation failed',
-          details: validation.error.issues,
+          details: normalizeDefinitionValidationIssues(validation.error),
         },
         { status: 400 }
       )
@@ -226,11 +262,21 @@ export async function POST(request: NextRequest) {
 
     const input: CreateWorkflowDefinitionApiInput = validation.data
 
-    // workflow_id is unique per tenant; check upfront to return 409 instead of DB error.
+    // New definitions default to strict interpolation (spec §3.6). The default
+    // lives on the create path only — a schema-level default would flip
+    // existing lenient definitions on their next full-body update.
+    const definitionData = input.definition.interpolation
+      ? input.definition
+      : { ...input.definition, interpolation: 'strict' as const }
+
+    // Create always mints version 1. A workflowId that already exists (any
+    // version) is a conflict — new versions are produced via the publish flow,
+    // not by re-creating. orderBy keeps the existence check deterministic now
+    // that multiple versions can coexist.
     const existing = await em.findOne(WorkflowDefinition, {
       workflowId: input.workflowId,
       tenantId,
-    })
+    }, { orderBy: { version: 'DESC' } })
 
     if (existing) {
       return NextResponse.json(
@@ -241,21 +287,48 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    // Create workflow definition
+    const grantedFeatures = normalizeGrantedFeatures(input.grantedFeatures)
+    const grantFailure = await authorizeWorkflowGrantChange(rbacService, {
+      userId: auth.sub,
+      scope: { tenantId, organizationId },
+      requested: grantedFeatures,
+      current: [],
+    })
+    if (grantFailure) {
+      return NextResponse.json(grantFailure.body, { status: grantFailure.status })
+    }
+
+    // Create workflow definition.
+    //
+    // The PK is minted up front (MikroORM does not generate UUIDs client-side)
+    // so the execution principal — whose identity key is the definition id — can
+    // be provisioned BEFORE the row claiming the grant is persisted. A failed
+    // provisioning then leaves no definition pointing at a principal that does
+    // not exist.
+    //
+    // `createdBy` is recorded here for the first time. It was never set on this
+    // path, which silently disabled the definition-author fallback CALL_API and
+    // INVOKE_AGENT rely on for event-triggered runs.
     const definition = em.create(WorkflowDefinition, {
+      id: randomUUID(),
       workflowId: input.workflowId,
       workflowName: input.workflowName,
       description: input.description,
       version: input.version,
-      definition: input.definition,
+      definition: definitionData,
       metadata: input.metadata,
       enabled: input.enabled ?? true,
+      grantedFeatures: grantedFeatures.length ? grantedFeatures : null,
       tenantId,
       organizationId,
+      createdBy: auth.sub,
+      updatedBy: auth.sub,
       createdAt: new Date(),
       updatedAt: new Date(),
     })
 
+    await syncWorkflowDefinitionPrincipal(container, definition)
+
     await em.persist(definition).flush()
 
     // Newly-created embedded triggers must be visible to the wildcard event
@@ -302,6 +375,7 @@ export const openApi = {
         {
           status: 200,
           description: 'List of workflow definitions with pagination',
+          schema: workflowDefinitionListResponseSchema,
           example: {
             data: [
               {
@@ -439,6 +513,7 @@ export const openApi = {
         {
           status: 201,
           description: 'Workflow definition created successfully',
+          schema: workflowDefinitionMutationResponseSchema,
           example: {
             data: {
               id: '123e4567-e89b-12d3-a456-426614174000',
@@ -494,13 +569,14 @@ export const openApi = {
         {
           status: 400,
           description: 'Validation error - invalid workflow structure',
+          schema: workflowErrorSchema,
           example: {
             error: 'Validation failed',
             details: [
               {
-                code: 'invalid_type',
-                message: 'Workflow must have at least START and END steps',
                 path: ['definition', 'steps'],
+                code: 'custom',
+                message: 'Workflow must have at least START and END steps',
               },
             ],
           },
@@ -508,6 +584,7 @@ export const openApi = {
         {
           status: 409,
           description: 'Conflict - workflow with same ID and version already exists',
+          schema: workflowErrorSchema,
           example: {
             error: 'Workflow definition with ID "checkout-flow" and version 1 already exists',
           },
@@ -517,105 +594,3 @@ export const openApi = {
   },
 }
 
-// Full OpenAPI documentation (kept for reference but not used by type system)
-export const _openApiDetailedDocs = {
-  get: {
-    summary: 'List workflow definitions',
-    description: 'Get a list of workflow definitions with optional filters',
-    tags: ['Workflows'],
-    parameters: [
-      {
-        name: 'enabled',
-        in: 'query',
-        description: 'Filter by enabled status',
-        schema: { type: 'boolean' },
-      },
-      {
-        name: 'workflowId',
-        in: 'query',
-        description: 'Filter by workflow ID',
-        schema: { type: 'string' },
-      },
-      {
-        name: 'search',
-        in: 'query',
-        description: 'Search in workflow ID and name',
-        schema: { type: 'string' },
-      },
-      {
-        name: 'limit',
-        in: 'query',
-        description: 'Number of results to return',
-        schema: { type: 'integer', default: 50 },
-      },
-      {
-        name: 'offset',
-        in: 'query',
-        description: 'Offset for pagination',
-        schema: { type: 'integer', default: 0 },
-      },
-    ],
-    responses: {
-      200: {
-        description: 'List of workflow definitions',
-        content: {
-          'application/json': {
-            schema: {
-              type: 'object',
-              properties: {
-                data: {
-                  type: 'array',
-                  items: { $ref: '#/components/schemas/WorkflowDefinition' },
-                },
-                pagination: {
-                  type: 'object',
-                  properties: {
-                    total: { type: 'integer' },
-                    limit: { type: 'integer' },
-                    offset: { type: 'integer' },
-                    hasMore: { type: 'boolean' },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-  post: {
-    summary: 'Create workflow definition',
-    description: 'Create a new workflow definition',
-    tags: ['Workflows'],
-    requestBody: {
-      required: true,
-      content: {
-        'application/json': {
-          schema: { $ref: '#/components/schemas/CreateWorkflowDefinition' },
-        },
-      },
-    },
-    responses: {
-      201: {
-        description: 'Workflow definition created',
-        content: {
-          'application/json': {
-            schema: {
-              type: 'object',
-              properties: {
-                data: { $ref: '#/components/schemas/WorkflowDefinition' },
-                message: { type: 'string' },
-              },
-            },
-          },
-        },
-      },
-      400: {
-        description: 'Validation error',
-      },
-      409: {
-        description: 'Workflow definition already exists',
-      },
-    },
-  },
-}

package/src/modules/workflows/api/definitions/serialize.ts

@@ -24,10 +24,13 @@ export function serializeWorkflowDefinition(definition: WorkflowDefinition) {
     definition: definition.definition,
     metadata: definition.metadata ?? null,
     enabled: definition.enabled,
+    kind: definition.kind,
+    lifecycle: definition.lifecycle,
     effectiveFrom: definition.effectiveFrom ?? null,
     effectiveTo: definition.effectiveTo ?? null,
     tenantId: definition.tenantId,
     organizationId: definition.organizationId,
+    grantedFeatures: definition.grantedFeatures ?? null,
     createdBy: definition.createdBy ?? null,
     updatedBy: definition.updatedBy ?? null,
     createdAt: definition.createdAt,
@@ -49,10 +52,16 @@ export function serializeCodeWorkflowDefinition(codeDef: CodeWorkflowDefinition,
     definition: codeDef.definition,
     metadata: codeDef.metadata ?? null,
     enabled: codeDef.enabled,
+    // Code-based definitions are normal, published workflows (never components).
+    kind: 'workflow' as const,
+    lifecycle: 'published' as const,
     effectiveFrom: null,
     effectiveTo: null,
     tenantId: null,
     organizationId: null,
+    // Code-based definitions carry no execution grant: they are not editable
+    // rows, so there is nothing to authorise a grant against.
+    grantedFeatures: null,
     createdBy: null,
     updatedBy: null,
     createdAt: null,

package/src/modules/workflows/api/endpoints/route.ts

@@ -0,0 +1,88 @@
+/**
+ * Workflow Endpoint Catalog API (issue #4235)
+ *
+ * Endpoint:
+ * - GET /api/workflows/endpoints - Trimmed index of the platform API surface for the CALL_API endpoint picker
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { getWorkflowEndpointCatalog } from '../../lib/endpoint-catalog'
+import { workflowsTag, workflowErrorSchema, workflowEndpointListResponseSchema } from '../openapi'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['workflows.definitions.view'],
+}
+
+/**
+ * GET /api/workflows/endpoints
+ *
+ * List the endpoint catalog projected from the in-process OpenAPI surface for
+ * the CALL_API endpoint picker.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(request)
+
+    if (!auth) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
+    const tenantId = auth.tenantId
+    const organizationId = scope?.selectedId ?? auth.orgId
+
+    if (!tenantId) {
+      return NextResponse.json({ error: 'Missing tenant context' }, { status: 400 })
+    }
+
+    const rbacService = container.resolve('rbacService')
+    const hasPermission = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['workflows.definitions.view'],
+      { tenantId, organizationId }
+    )
+
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Insufficient permissions' }, { status: 403 })
+    }
+
+    const catalog = await getWorkflowEndpointCatalog()
+
+    return NextResponse.json({ items: catalog.items })
+  } catch (error) {
+    logger.error('Error listing workflow endpoint catalog', { err: error })
+    return NextResponse.json(
+      { error: 'Failed to list workflow endpoint catalog' },
+      { status: 500 }
+    )
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: workflowsTag,
+  summary: 'List the workflow endpoint catalog',
+  methods: {
+    GET: {
+      summary: 'List endpoints available to CALL_API activities',
+      description: 'Returns a trimmed projection of the OpenAPI surface (path, method, summary, tag, parameters, and declared request/response schemas) consumed by the CALL_API endpoint picker. Endpoints outside this catalog can still be authored as free text. Responses without a declared schema omit responseSchema so consumers degrade to unknown typing.',
+      responses: [
+        { status: 200, description: 'Endpoint catalog projected from the OpenAPI surface', schema: workflowEndpointListResponseSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Missing tenant context', schema: workflowErrorSchema },
+        { status: 401, description: 'Unauthorized', schema: workflowErrorSchema },
+        { status: 403, description: 'Insufficient permissions', schema: workflowErrorSchema },
+        { status: 500, description: 'Internal server error', schema: workflowErrorSchema },
+      ],
+    },
+  },
+}

package/src/modules/workflows/api/functions/route.ts

@@ -0,0 +1,91 @@
+/**
+ * Workflow Functions API
+ *
+ * Endpoint:
+ * - GET /api/workflows/functions - List registered workflow function descriptors for EXECUTE_FUNCTION activities
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { listWorkflowFunctions } from '../../lib/workflow-function-registry'
+import { workflowsTag, workflowErrorSchema, workflowFunctionListResponseSchema } from '../openapi'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['workflows.definitions.edit'],
+}
+
+/**
+ * GET /api/workflows/functions
+ *
+ * List the registered workflow function descriptors for the EXECUTE_FUNCTION function picker.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(request)
+
+    if (!auth) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
+    const tenantId = auth.tenantId
+    const organizationId = scope?.selectedId ?? auth.orgId
+
+    if (!tenantId) {
+      return NextResponse.json({ error: 'Missing tenant context' }, { status: 400 })
+    }
+
+    const rbacService = container.resolve('rbacService')
+    const hasPermission = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['workflows.definitions.edit'],
+      { tenantId, organizationId }
+    )
+
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Insufficient permissions' }, { status: 403 })
+    }
+
+    const items = listWorkflowFunctions().map((definition) => ({
+      name: definition.name,
+      ...(definition.labelKey ? { labelKey: definition.labelKey } : {}),
+      ...(definition.description ? { description: definition.description } : {}),
+    }))
+
+    return NextResponse.json({ items })
+  } catch (error) {
+    logger.error('Error listing workflow functions', { err: error })
+    return NextResponse.json(
+      { error: 'Failed to list workflow functions' },
+      { status: 500 }
+    )
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: workflowsTag,
+  summary: 'List workflow functions',
+  methods: {
+    GET: {
+      summary: 'List registered workflow function descriptors for EXECUTE_FUNCTION activities',
+      description: 'Returns the registered workflow function descriptors consumed by the EXECUTE_FUNCTION function picker. Functions outside this list can still be authored but fail at runtime when no matching workflowFunction:<name> DI registration exists.',
+      responses: [
+        { status: 200, description: 'Registered workflow function descriptors', schema: workflowFunctionListResponseSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Missing tenant context', schema: workflowErrorSchema },
+        { status: 401, description: 'Unauthorized', schema: workflowErrorSchema },
+        { status: 403, description: 'Insufficient permissions', schema: workflowErrorSchema },
+        { status: 500, description: 'Internal server error', schema: workflowErrorSchema },
+      ],
+    },
+  },
+}

package/src/modules/workflows/api/grantable-features/route.ts

@@ -0,0 +1,102 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { getModules } from '@open-mercato/shared/lib/i18n/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { hasFeature } from '@open-mercato/shared/security/features'
+import { WORKFLOW_GRANT_FEATURE } from '../../lib/definition-grant'
+
+/**
+ * The vocabulary a workflow author may put into a definition's execution grant.
+ *
+ * Unlike `auth`'s catalog (gated `auth.acl.manage`) and `agent_orchestrator`'s
+ * (which lists every declared feature), this one is INTERSECTED with the
+ * caller's own current grants: the save-time rule is that a grant can never
+ * exceed the granting user's features, so offering ids that would be refused on
+ * save would only produce checkboxes that fail. Ids + titles only — no role or
+ * grant data for anyone else leaks through.
+ */
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: [WORKFLOW_GRANT_FEATURE] },
+}
+
+type GrantableFeature = { id: string; title: string; module: string }
+
+const grantableFeatureSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  module: z.string(),
+})
+
+type RbacServiceLike = {
+  getGrantedFeatures?: (
+    userId: string,
+    scope: { tenantId: string | null; organizationId: string | null },
+  ) => Promise<string[]>
+}
+
+export async function GET(request: Request) {
+  const auth = await getAuthFromRequest(request)
+  if (!auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+  const container = await createRequestContainer()
+  const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
+  const organizationId = scope?.selectedId ?? auth.orgId ?? null
+  const tenantId = auth.tenantId ?? null
+
+  const rbacService = container.resolve('rbacService') as RbacServiceLike
+  const granted = rbacService.getGrantedFeatures
+    ? await rbacService.getGrantedFeatures(auth.sub, { tenantId, organizationId })
+    : []
+
+  const byId = new Map<string, GrantableFeature>()
+  for (const mod of getModules() || []) {
+    const features = (mod as { features?: Array<Record<string, unknown>> }).features || []
+    for (const feature of features) {
+      const id = typeof feature.id === 'string' ? feature.id.trim() : ''
+      if (!id || byId.has(id)) continue
+      // Wildcard-aware: an author holding `catalog.*` may grant every concrete
+      // `catalog.…` id. Never an exact-string check.
+      if (!hasFeature(granted, id)) continue
+      byId.set(id, {
+        id,
+        title: typeof feature.title === 'string' && feature.title ? feature.title : id,
+        module: typeof feature.module === 'string' && feature.module ? feature.module : String(mod.id ?? ''),
+      })
+    }
+  }
+
+  const items = Array.from(byId.values()).sort(
+    (a, b) => a.module.localeCompare(b.module) || a.id.localeCompare(b.id),
+  )
+  return NextResponse.json({ items })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Workflows',
+  summary: 'List the ACL features the caller may grant to a workflow definition',
+  methods: {
+    GET: {
+      summary: 'List grantable execution features',
+      description:
+        'Declared ACL feature ids/titles intersected with the calling user’s own current grants (wildcard-aware). Drives the definition editor’s execution-permissions picker; gated by workflows.definitions.grant_features.',
+      responses: [
+        {
+          status: 200,
+          description: 'Grantable feature catalog',
+          schema: z.object({ items: z.array(grantableFeatureSchema) }),
+        },
+      ],
+      errors: [
+        { status: 401, description: 'Unauthorized', schema: z.object({ error: z.string() }) },
+        {
+          status: 403,
+          description: 'Missing workflows.definitions.grant_features',
+          schema: z.object({ error: z.string() }),
+        },
+      ],
+    },
+  },
+}