@open-mercato/core 0.6.7-develop.6788.1.c2a1520a30 → 0.6.7-develop.6814.1.0627c7e9f1

package/src/modules/design_system/i18n/es.json

@@ -0,0 +1,46 @@
+{
+  "design_system.entries.button.description": "Disparador de acción principal con toda la escala de variantes y tamaños del DS.",
+  "design_system.entries.buttonGroup.description": "Grupo unido de botones de acción relacionados que comparten un borde.",
+  "design_system.entries.fancyButton.description": "Botón con degradado, de estilo promocional, para acciones destacadas.",
+  "design_system.entries.iconButton.description": "Botón cuadrado solo con icono; siempre requiere un aria-label.",
+  "design_system.entries.linkButton.description": "Enlace de texto con estilo de control del DS.",
+  "design_system.entries.socialButton.description": "Botón de autenticación con colores de marca para inicio de sesión social.",
+  "design_system.families.banners": "Avisos y llamadas",
+  "design_system.families.buttons": "Botones",
+  "design_system.families.charts": "Gráficos",
+  "design_system.families.dates": "Fechas y hora",
+  "design_system.families.detail": "Secciones de detalle",
+  "design_system.families.display": "Visualización de datos",
+  "design_system.families.feedback": "Retroalimentación",
+  "design_system.families.filters": "Filtros",
+  "design_system.families.foundations": "Fundamentos",
+  "design_system.families.icons": "Iconos",
+  "design_system.families.inputs": "Campos de formulario",
+  "design_system.families.messages": "Mensajes",
+  "design_system.families.navigation": "Navegación",
+  "design_system.families.notifications": "Notificaciones",
+  "design_system.families.overlays": "Superposiciones",
+  "design_system.families.scaffolding": "Estructura de página",
+  "design_system.families.schedule": "Agenda",
+  "design_system.gallery.copied": "Fragmento copiado al portapapeles",
+  "design_system.gallery.copy": "Copiar código",
+  "design_system.gallery.copyFailed": "No se pudo copiar el fragmento",
+  "design_system.gallery.familiesGroup": "Familias",
+  "design_system.gallery.familyContents": "Componentes de esta familia",
+  "design_system.gallery.iconCopied": "Copiado: {snippet}",
+  "design_system.gallery.iconCopyJsx": "Copiar JSX (lucide-react)",
+  "design_system.gallery.iconCopyMeta": "Copiar nombre para page.meta icon",
+  "design_system.gallery.iconCountAll": "{total} iconos",
+  "design_system.gallery.iconCountFiltered": "{visible} de {total} iconos",
+  "design_system.gallery.iconSearchPlaceholder": "Filtrar iconos…",
+  "design_system.gallery.loadFailed": "No se pudo cargar esta familia",
+  "design_system.gallery.noResults": "Ningún componente coincide con la búsqueda",
+  "design_system.gallery.openInFigma": "Abrir en Figma",
+  "design_system.gallery.retry": "Reintentar",
+  "design_system.gallery.searchPlaceholder": "Buscar componentes…",
+  "design_system.gallery.usageDo": "Haz",
+  "design_system.gallery.usageDont": "Evita",
+  "design_system.gallery.viewDocs": "Ver documentación",
+  "design_system.nav.group": "Desarrollador",
+  "design_system.nav.title": "Sistema de diseño"
+}

package/src/modules/design_system/i18n/pl.json

@@ -0,0 +1,46 @@
+{
+  "design_system.entries.button.description": "Podstawowy przycisk akcji z pełną skalą wariantów i rozmiarów DS.",
+  "design_system.entries.buttonGroup.description": "Połączona grupa powiązanych przycisków akcji ze wspólnym obramowaniem.",
+  "design_system.entries.fancyButton.description": "Gradientowy przycisk o marketingowym charakterze dla wyróżnionych akcji.",
+  "design_system.entries.iconButton.description": "Kwadratowy przycisk z samą ikoną; zawsze wymaga aria-label.",
+  "design_system.entries.linkButton.description": "Tekstowy odnośnik w stylu kontrolki DS.",
+  "design_system.entries.socialButton.description": "Przycisk logowania w kolorach marki dla logowania społecznościowego.",
+  "design_system.families.banners": "Banery i wskazówki",
+  "design_system.families.buttons": "Przyciski",
+  "design_system.families.charts": "Wykresy",
+  "design_system.families.dates": "Daty i czas",
+  "design_system.families.detail": "Sekcje szczegółów",
+  "design_system.families.display": "Prezentacja danych",
+  "design_system.families.feedback": "Informacje zwrotne",
+  "design_system.families.filters": "Filtry",
+  "design_system.families.foundations": "Fundamenty",
+  "design_system.families.icons": "Ikony",
+  "design_system.families.inputs": "Pola formularzy",
+  "design_system.families.messages": "Wiadomości",
+  "design_system.families.navigation": "Nawigacja",
+  "design_system.families.notifications": "Powiadomienia",
+  "design_system.families.overlays": "Nakładki",
+  "design_system.families.scaffolding": "Szkielet strony",
+  "design_system.families.schedule": "Harmonogram",
+  "design_system.gallery.copied": "Fragment skopiowany do schowka",
+  "design_system.gallery.copy": "Kopiuj kod",
+  "design_system.gallery.copyFailed": "Nie udało się skopiować fragmentu",
+  "design_system.gallery.familiesGroup": "Rodziny",
+  "design_system.gallery.familyContents": "Komponenty w tej rodzinie",
+  "design_system.gallery.iconCopied": "Skopiowano: {snippet}",
+  "design_system.gallery.iconCopyJsx": "Kopiuj JSX (lucide-react)",
+  "design_system.gallery.iconCopyMeta": "Kopiuj nazwę do page.meta icon",
+  "design_system.gallery.iconCountAll": "Ikony: {total}",
+  "design_system.gallery.iconCountFiltered": "{visible} z {total} ikon",
+  "design_system.gallery.iconSearchPlaceholder": "Filtruj ikony…",
+  "design_system.gallery.loadFailed": "Nie udało się załadować tej rodziny",
+  "design_system.gallery.noResults": "Żaden komponent nie pasuje do wyszukiwania",
+  "design_system.gallery.openInFigma": "Otwórz w Figmie",
+  "design_system.gallery.retry": "Spróbuj ponownie",
+  "design_system.gallery.searchPlaceholder": "Szukaj komponentów…",
+  "design_system.gallery.usageDo": "Rób",
+  "design_system.gallery.usageDont": "Unikaj",
+  "design_system.gallery.viewDocs": "Zobacz dokumentację",
+  "design_system.nav.group": "Deweloper",
+  "design_system.nav.title": "Design system"
+}

package/src/modules/design_system/index.ts

@@ -0,0 +1,7 @@
+import type { ModuleInfo } from '@open-mercato/shared/modules/registry'
+
+export const metadata: ModuleInfo = {
+  name: 'design_system',
+  title: 'Design system gallery',
+  description: 'Live, in-app component gallery for the Open Mercato design system.',
+}

package/src/modules/design_system/setup.ts

@@ -0,0 +1,12 @@
+import type { ModuleSetupConfig } from '@open-mercato/shared/modules/setup'
+
+export const setup: ModuleSetupConfig = {
+  defaultRoleFeatures: {
+    // View-only module: the gallery reads no tenant data, so the grant is safe
+    // to hand out broadly. Superadmin is covered by wildcard grants.
+    admin: ['design_system.view'],
+    employee: ['design_system.view'],
+  },
+}
+
+export default setup

package/src/modules/entities/api/entity-settings.ts

@@ -3,6 +3,10 @@ import { z } from 'zod'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { beginEntitiesMutationGuard } from './definitions.mutation-guard'
+import { enforceCommandOptimisticLockWithGuards } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import type { ModuleConfigService } from '../../configs/lib/module-config-service'
 
 // Tenant-scoped policy: when true, new custom entities are created with
 // `access_restricted = true` unless the create request explicitly sets the flag.
@@ -14,24 +18,10 @@ export const metadata = {
   PUT: { requireAuth: true, requireFeatures: ['entities.definitions.manage'] },
 }
 
-type ModuleConfigServiceLike = {
-  getValue: (
-    moduleId: string,
-    name: string,
-    options?: { defaultValue?: unknown; scope?: { tenantId?: string | null } },
-  ) => Promise<unknown>
-  setValue: (
-    moduleId: string,
-    name: string,
-    value: unknown,
-    scope?: { tenantId?: string | null },
-  ) => Promise<unknown>
-}
-
 async function readPolicy(tenantId: string | null): Promise<boolean> {
   try {
     const { resolve } = await createRequestContainer()
-    const moduleConfigService = resolve('moduleConfigService') as ModuleConfigServiceLike
+    const moduleConfigService = resolve('moduleConfigService') as ModuleConfigService
     const value = await moduleConfigService.getValue(CONFIG_MODULE, NEW_ENTITIES_RESTRICTED_KEY, {
       defaultValue: false,
       scope: { tenantId },
@@ -45,12 +35,20 @@ async function readPolicy(tenantId: string | null): Promise<boolean> {
 export async function GET(req: Request) {
   const auth = await getAuthFromRequest(req)
   if (!auth || !auth.tenantId) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  const newEntitiesRestrictedByDefault = await readPolicy(auth.tenantId ?? null)
-  return NextResponse.json({ newEntitiesRestrictedByDefault })
+  const { resolve } = await createRequestContainer()
+  const moduleConfigService = resolve('moduleConfigService') as ModuleConfigService
+  const record = await moduleConfigService.getRecord(CONFIG_MODULE, NEW_ENTITIES_RESTRICTED_KEY, {
+    tenantId: auth.tenantId ?? null,
+  })
+  return NextResponse.json({
+    newEntitiesRestrictedByDefault: record ? record.value === true : false,
+    updatedAt: record ? record.updatedAt : null,
+  })
 }
 
 const putBodySchema = z.object({
   newEntitiesRestrictedByDefault: z.boolean(),
+  expectedUpdatedAt: z.string().optional(),
 })
 
 export async function PUT(req: Request) {
@@ -62,19 +60,64 @@ export async function PUT(req: Request) {
   if (!parsed.success) {
     return NextResponse.json({ error: 'Validation failed', details: parsed.error.flatten() }, { status: 400 })
   }
-  const { resolve } = await createRequestContainer()
-  const moduleConfigService = resolve('moduleConfigService') as ModuleConfigServiceLike
-  await moduleConfigService.setValue(
+  const container = await createRequestContainer()
+  const { resolve } = container
+  const moduleConfigService = resolve('moduleConfigService') as ModuleConfigService
+
+  const currentRecord = await moduleConfigService.getRecord(
+    CONFIG_MODULE,
+    NEW_ENTITIES_RESTRICTED_KEY,
+    { tenantId: auth.tenantId ?? null },
+  )
+
+  const guard = await beginEntitiesMutationGuard({
+    container,
+    auth,
+    req,
+    resourceKind: 'entities.settings',
+    resourceId: NEW_ENTITIES_RESTRICTED_KEY,
+    operation: currentRecord ? 'update' : 'create',
+    mutationPayload: parsed.data as unknown as Record<string, unknown>,
+  })
+  if (guard.blockedResponse) return guard.blockedResponse
+
+  const ifMatchHeader = req.headers.get('If-Match') || req.headers.get('x-om-ext-optimistic-lock-expected-updated-at')
+  const expectedUpdatedAt = ifMatchHeader || parsed.data.expectedUpdatedAt
+
+  try {
+    await enforceCommandOptimisticLockWithGuards(container, {
+      resourceKind: 'entities.settings',
+      resourceId: NEW_ENTITIES_RESTRICTED_KEY,
+      current: currentRecord ? currentRecord.updatedAt : null,
+      expected: expectedUpdatedAt,
+      request: req,
+    })
+  } catch (lockError) {
+    if (isCrudHttpError(lockError)) {
+      return NextResponse.json(lockError.body, { status: lockError.status })
+    }
+    throw lockError
+  }
+
+  const updatedRecord = await moduleConfigService.setValue(
     CONFIG_MODULE,
     NEW_ENTITIES_RESTRICTED_KEY,
     parsed.data.newEntitiesRestrictedByDefault,
     { tenantId: auth.tenantId ?? null },
   )
-  return NextResponse.json({ ok: true, newEntitiesRestrictedByDefault: parsed.data.newEntitiesRestrictedByDefault })
+
+  await guard.runAfterSuccess()
+
+  return NextResponse.json({
+    ok: true,
+    newEntitiesRestrictedByDefault: parsed.data.newEntitiesRestrictedByDefault,
+    updatedAt: updatedRecord ? updatedRecord.updatedAt : null,
+  })
 }
 
 const settingsResponseSchema = z.object({
   newEntitiesRestrictedByDefault: z.boolean(),
+  updatedAt: z.string().nullable().optional(),
 })
 
 export const openApi: OpenApiRouteDoc = {
@@ -94,9 +137,10 @@ export const openApi: OpenApiRouteDoc = {
       description: 'Sets the tenant-scoped default-restricted policy for new custom entities.',
       requestBody: { schema: putBodySchema },
       responses: [
-        { status: 200, description: 'Updated settings', schema: z.object({ ok: z.boolean(), newEntitiesRestrictedByDefault: z.boolean() }) },
+        { status: 200, description: 'Updated settings', schema: z.object({ ok: z.boolean(), newEntitiesRestrictedByDefault: z.boolean(), updatedAt: z.string().nullable().optional() }) },
         { status: 400, description: 'Invalid payload', schema: z.object({ error: z.string() }) },
         { status: 401, description: 'Missing authentication', schema: z.object({ error: z.string() }) },
+        { status: 409, description: 'Optimistic lock conflict', schema: z.object({ code: z.string(), error: z.string() }) },
       ],
     },
   },

package/src/modules/entities/backend/config/settings/page.meta.ts

@@ -0,0 +1,34 @@
+import React from 'react'
+
+const settingsIcon = React.createElement(
+  'svg',
+  {
+    width: 16,
+    height: 16,
+    viewBox: '0 0 24 24',
+    fill: 'none',
+    stroke: 'currentColor',
+    strokeWidth: 2,
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+  },
+  React.createElement('circle', { cx: 12, cy: 12, r: 3 }),
+  React.createElement('path', {
+    d: 'M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z'
+  })
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['entities.definitions.manage'],
+  pageTitle: 'Custom Entities',
+  pageTitleKey: 'entities.settings.title',
+  pageGroup: 'Module Configs',
+  pageGroupKey: 'settings.sections.moduleConfigs',
+  pageOrder: 5,
+  icon: settingsIcon,
+  pageContext: 'settings' as const,
+  breadcrumb: [
+    { label: 'Custom Entities', labelKey: 'entities.settings.title' },
+  ],
+} as const

package/src/modules/entities/backend/config/settings/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { EntitySettingsManager } from '../../../components/EntitySettingsManager'
+
+export default function EntitySettingsPage() {
+  return (
+    <Page>
+      <PageBody className="space-y-8">
+        <EntitySettingsManager />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/entities/backend/entities/user/create/page.tsx

@@ -10,6 +10,7 @@ import { useRouter } from 'next/navigation'
 import { pushWithFlash } from '@open-mercato/ui/backend/utils/flash'
 import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
 import { LoadingMessage } from '@open-mercato/ui/backend/detail'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
 
 const schema = upsertCustomEntitySchema
 
@@ -24,15 +25,23 @@ export default function CreateEntityPage() {
   React.useEffect(() => {
     let active = true
     ;(async () => {
-      const data = await readApiResultOrThrow<{ newEntitiesRestrictedByDefault?: boolean }>(
-        '/api/entities/entity-settings',
-        undefined,
-        { errorMessage: '[internal] Failed to load entity settings', fallback: { newEntitiesRestrictedByDefault: false } },
-      ).catch(() => ({ newEntitiesRestrictedByDefault: false }))
-      if (active) setDefaultRestricted(data?.newEntitiesRestrictedByDefault === true)
+      try {
+        const data = await readApiResultOrThrow<{ newEntitiesRestrictedByDefault?: boolean }>(
+          '/api/entities/entity-settings',
+          undefined,
+          {
+            errorMessage: t('entities.userEntities.errors.settingsLoadFailed', 'Could not load default restriction policy; using default'),
+            fallback: { newEntitiesRestrictedByDefault: false },
+          },
+        )
+        if (active) setDefaultRestricted(data?.newEntitiesRestrictedByDefault === true)
+      } catch {
+        flash(t('entities.userEntities.errors.settingsLoadFailed', 'Could not load default restriction policy; using default'), 'warning')
+        if (active) setDefaultRestricted(false)
+      }
     })()
     return () => { active = false }
-  }, [])
+  }, [t])
   const fields = React.useMemo<CrudField[]>(() => ([
     {
       id: 'entityId',

package/src/modules/entities/components/EntitySettingsManager.tsx

@@ -0,0 +1,160 @@
+"use client"
+
+import * as React from 'react'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Checkbox } from '@open-mercato/ui/primitives/checkbox'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { apiCall, apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { ErrorMessage } from '@open-mercato/ui/backend/detail'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { buildOptimisticLockHeader, extractOptimisticLockConflict } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+
+export function EntitySettingsManager(): React.ReactElement {
+  const t = useT()
+  const [loading, setLoading] = React.useState(true)
+  const [loadError, setLoadError] = React.useState(false)
+  const [saving, setSaving] = React.useState(false)
+  const [restricted, setRestricted] = React.useState(false)
+  const [updatedAt, setUpdatedAt] = React.useState<string | null>(null)
+
+  const { runMutation } = useGuardedMutation({
+    contextId: 'custom-entities-settings',
+  })
+
+  const loadSettings = React.useCallback(async () => {
+    setLoading(true)
+    setLoadError(false)
+    try {
+      const data = await readApiResultOrThrow<{ newEntitiesRestrictedByDefault?: boolean; updatedAt?: string | null }>(
+        '/api/entities/entity-settings',
+        undefined,
+        {
+          errorMessage: t('entities.settings.errors.loadFailed', 'Failed to load settings'),
+        }
+      )
+      setRestricted(data.newEntitiesRestrictedByDefault === true)
+      setUpdatedAt(data.updatedAt ?? null)
+    } catch {
+      setLoadError(true)
+    } finally {
+      setLoading(false)
+    }
+  }, [t])
+
+  React.useEffect(() => {
+    void loadSettings()
+  }, [loadSettings])
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setSaving(true)
+    try {
+      const headers = buildOptimisticLockHeader(updatedAt)
+      await runMutation({
+        operation: () =>
+          withScopedApiRequestHeaders(headers, async () => {
+            const res = await apiCallOrThrow<{ ok: boolean; newEntitiesRestrictedByDefault: boolean; updatedAt: string | null }>(
+              '/api/entities/entity-settings',
+              {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                  newEntitiesRestrictedByDefault: restricted,
+                  expectedUpdatedAt: updatedAt ?? undefined,
+                }),
+              },
+              {
+                errorMessage: t('entities.settings.errors.saveFailed', 'Failed to save settings'),
+              }
+            )
+
+            if (res.ok && res.result) {
+              setUpdatedAt(res.result.updatedAt)
+              flash(t('entities.settings.flash.saved', 'Settings saved'), 'success')
+            }
+            return res
+          }),
+        context: {},
+        mutationPayload: {
+          newEntitiesRestrictedByDefault: restricted,
+        },
+      })
+    } catch (err) {
+      const conflict = extractOptimisticLockConflict(err)
+      if (conflict) {
+        setLoading(true)
+        await loadSettings()
+      } else {
+        flash(t('entities.settings.errors.saveFailed', 'Failed to save settings'), 'error')
+      }
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  if (loading) {
+    return (
+      <div className="flex items-center gap-2 text-sm text-muted-foreground">
+        <Spinner className="h-4 w-4" />
+        <span>{t('entities.userEntities.form.loading', 'Loading…')}</span>
+      </div>
+    )
+  }
+
+  if (loadError) {
+    return (
+      <ErrorMessage
+        label={t('entities.settings.errors.loadFailed', 'Failed to load settings')}
+        action={(
+          <Button type="button" variant="outline" size="sm" onClick={() => void loadSettings()}>
+            {t('common.retry', 'Retry')}
+          </Button>
+        )}
+      />
+    )
+  }
+
+  return (
+    <form onSubmit={(e) => void handleSubmit(e)} className="space-y-6 max-w-2xl">
+      <div className="space-y-1">
+        <h3 className="text-base font-semibold">
+          {t('entities.settings.title', 'Custom Entities')}
+        </h3>
+        <p className="text-sm text-muted-foreground">
+          {t('entities.settings.description', 'Manage global custom entity configurations.')}
+        </p>
+      </div>
+
+      <div className="rounded-lg border bg-card p-4 space-y-4">
+        <div className="flex items-start gap-3">
+          <Checkbox
+            id="newEntitiesRestrictedByDefault"
+            checked={restricted}
+            onCheckedChange={(checked) => setRestricted(checked === true)}
+            disabled={saving}
+            className="mt-1"
+          />
+          <div className="space-y-1">
+            <Label htmlFor="newEntitiesRestrictedByDefault" className="font-medium cursor-pointer">
+              {t('entities.settings.newEntitiesRestrictedByDefault.label', 'Restrict record access by default')}
+            </Label>
+            <p className="text-sm text-muted-foreground">
+              {t('entities.settings.newEntitiesRestrictedByDefault.description', 'Require explicit per-entity permissions for records of newly created custom entities by default.')}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <div className="flex items-center justify-end gap-3 border-t pt-4">
+        <Button type="submit" disabled={saving}>
+          {saving ? <Spinner className="mr-2 h-4 w-4" /> : null}
+          {t('common.save', 'Save')}
+        </Button>
+      </div>
+    </form>
+  )
+}

package/src/modules/entities/i18n/de.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Systementitäten",
   "entities.nav.userEntities": "Benutzerentitäten",
   "entities.nav.userEntities.create": "Entität erstellen",
+  "entities.settings.description": "Globale Konfigurationen für benutzerdefinierte Entitäten verwalten.",
+  "entities.settings.errors.conflict": "Die Einstellungen wurden von einem anderen Benutzer geändert. Bitte neu laden.",
+  "entities.settings.errors.loadFailed": "Laden der Einstellungen fehlgeschlagen",
+  "entities.settings.errors.saveFailed": "Speichern der Einstellungen fehlgeschlagen",
+  "entities.settings.flash.saved": "Einstellungen gespeichert",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Für Datensätze neu erstellter benutzerdefinierter Entitäten standardmäßig explizite Berechtigungen pro Entität erfordern.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Datensatzzugriff standardmäßig einschränken",
+  "entities.settings.title": "Benutzerdefinierte Entitäten",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Entität konnte nicht gelöscht werden",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Die angeforderte Entitäts-ID fehlt oder ist ungültig.",
   "entities.userEntities.edit.errors.invalidEntityId": "Ungültige Entitäts-ID",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Entitäts-ID ist bereits vorhanden",
   "entities.userEntities.errors.entityIdRequired": "Entitäts-ID ist erforderlich",
   "entities.userEntities.errors.loadFailed": "Entitäten konnten nicht geladen werden",
+  "entities.userEntities.errors.settingsLoadFailed": "Standardeinschränkungsrichtlinie konnte nicht geladen werden; Standardwert wird verwendet",
   "entities.userEntities.flash.created": "Entität erstellt",
   "entities.userEntities.form.accessRestricted.help": "Erfordert eine explizite entitätsspezifische Berechtigung zum Anzeigen oder Verwalten der Datensätze dieser Entität. Deaktiviert lassen, um allen Benutzern mit der allgemeinen Datensatzberechtigung Zugriff zu gewähren.",
   "entities.userEntities.form.accessRestricted.label": "Datensatzzugriff einschränken",

package/src/modules/entities/i18n/en.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "System Entities",
   "entities.nav.userEntities": "User Entities",
   "entities.nav.userEntities.create": "Create Entity",
+  "entities.settings.description": "Manage global custom entity configurations.",
+  "entities.settings.errors.conflict": "Settings were modified by another user. Please reload.",
+  "entities.settings.errors.loadFailed": "Failed to load settings",
+  "entities.settings.errors.saveFailed": "Failed to save settings",
+  "entities.settings.flash.saved": "Settings saved",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Require explicit per-entity permissions for records of newly created custom entities by default.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Restrict record access by default",
+  "entities.settings.title": "Custom Entities",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Failed to delete entity",
   "entities.userEntities.edit.errors.invalidEntityDescription": "The requested entity ID is missing or invalid.",
   "entities.userEntities.edit.errors.invalidEntityId": "Invalid entity ID",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Entity ID already exists",
   "entities.userEntities.errors.entityIdRequired": "Entity ID is required",
   "entities.userEntities.errors.loadFailed": "Failed to load entities",
+  "entities.userEntities.errors.settingsLoadFailed": "Could not load default restriction policy; using default",
   "entities.userEntities.flash.created": "Entity created",
   "entities.userEntities.form.accessRestricted.help": "Require an explicit per-entity permission to view or manage this entity’s records. Leave off to allow anyone with the general records permission.",
   "entities.userEntities.form.accessRestricted.label": "Restrict record access",

package/src/modules/entities/i18n/es.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Entidades del sistema",
   "entities.nav.userEntities": "Entidades de usuario",
   "entities.nav.userEntities.create": "Crear entidad",
+  "entities.settings.description": "Administrar configuraciones globales de entidades personalizadas.",
+  "entities.settings.errors.conflict": "La configuración fue modificada por otro usuario. Por favor recarga.",
+  "entities.settings.errors.loadFailed": "Error al cargar la configuración",
+  "entities.settings.errors.saveFailed": "Error al guardar la configuración",
+  "entities.settings.flash.saved": "Configuración guardada",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Requerir permisos explícitos por entidad para registros de nuevas entidades creadas por defecto.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Restringir acceso a registros por defecto",
+  "entities.settings.title": "Entidades personalizadas",
   "entities.userEntities.edit.errors.deleteEntityFailed": "No se pudo eliminar la entidad",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Falta el ID de la entidad solicitada o no es válido.",
   "entities.userEntities.edit.errors.invalidEntityId": "ID de entidad no válido",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "El ID de la entidad ya existe",
   "entities.userEntities.errors.entityIdRequired": "El ID de la entidad es obligatorio",
   "entities.userEntities.errors.loadFailed": "No se pudieron cargar las entidades",
+  "entities.userEntities.errors.settingsLoadFailed": "No se pudo cargar la política de restricción por defecto; usando valor predeterminado",
   "entities.userEntities.flash.created": "Entidad creada",
   "entities.userEntities.form.accessRestricted.help": "Requiere un permiso explícito por entidad para ver o gestionar los registros de esta entidad. Déjalo desactivado para permitir el acceso a cualquiera con el permiso general de registros.",
   "entities.userEntities.form.accessRestricted.label": "Restringir acceso a registros",

package/src/modules/entities/i18n/pl.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Encje systemowe",
   "entities.nav.userEntities": "Encje użytkownika",
   "entities.nav.userEntities.create": "Utwórz encję",
+  "entities.settings.description": "Zarządzaj globalnymi ustawieniami niestandardowych encji.",
+  "entities.settings.errors.conflict": "Ustawienia zostały zmodyfikowane przez innego użytkownika. Proszę przeładować.",
+  "entities.settings.errors.loadFailed": "Nie udało się załadować ustawień",
+  "entities.settings.errors.saveFailed": "Nie udało się zapisać ustawień",
+  "entities.settings.flash.saved": "Ustawienia zostały zapisane",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Domyślnie wymagaj jawnych uprawnień dla poszczególnych encji do rekordów nowo tworzonych niestandardowych encji.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Domyślnie ograniczaj dostęp do rekordów",
+  "entities.settings.title": "Niestandardowe encje",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Nie udało się usunąć encji",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Brakuje identyfikatora encji albo jest on nieprawidłowy.",
   "entities.userEntities.edit.errors.invalidEntityId": "Nieprawidłowy identyfikator encji",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Identyfikator encji już istnieje",
   "entities.userEntities.errors.entityIdRequired": "Identyfikator encji jest wymagany",
   "entities.userEntities.errors.loadFailed": "Nie udało się wczytać encji",
+  "entities.userEntities.errors.settingsLoadFailed": "Nie udało się załadować domyślnej polityki ograniczeń; używanie wartości domyślnej",
   "entities.userEntities.flash.created": "Encja została utworzona",
   "entities.userEntities.form.accessRestricted.help": "Wymaga jawnego uprawnienia dla tej encji, aby przeglądać lub zarządzać jej rekordami. Pozostaw wyłączone, aby zezwolić na dostęp każdemu z ogólnym uprawnieniem do rekordów.",
   "entities.userEntities.form.accessRestricted.label": "Ogranicz dostęp do rekordów",

package/src/modules/inbox_ops/api/webhook/inbound.ts

@@ -13,6 +13,11 @@ import { parseInboundEmail } from '../../lib/emailParser'
 import { checkRateLimit } from '../../lib/rateLimiter'
 import { emitInboxOpsEvent } from '../../events'
 import { createLogger } from '@open-mercato/shared/lib/logger'
+import {
+  readBoundedRequestBody,
+  resolveWebhookBodyLimitBytes,
+  WebhookBodyTooLargeError,
+} from '@open-mercato/shared/lib/webhooks'
 
 const logger = createLogger('inbox_ops').child({ component: 'webhook' })
 
@@ -20,7 +25,10 @@ export const metadata = {
   POST: { requireAuth: false },
 }
 
-const MAX_PAYLOAD_SIZE = 2 * 1024 * 1024 // 2MB
+const MAX_PAYLOAD_SIZE = resolveWebhookBodyLimitBytes(
+  process.env.INBOX_OPS_WEBHOOK_MAX_BODY_BYTES ?? process.env.OM_WEBHOOK_MAX_BODY_BYTES,
+  2 * 1024 * 1024,
+)
 const REPLAY_WINDOW_MS = 5 * 60 * 1000 // 5 minutes
 
 function isTimestampFresh(timestamp: string): boolean {
@@ -211,22 +219,16 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'Service unavailable' }, { status: 503 })
   }
 
-  const contentLength = parseInt(req.headers.get('content-length') || '0', 10)
-  if (contentLength > MAX_PAYLOAD_SIZE) {
-    return NextResponse.json({ error: 'Payload too large' }, { status: 413 })
-  }
-
   let rawBody: string
   try {
-    rawBody = await req.text()
-  } catch {
+    rawBody = await readBoundedRequestBody(req, { maxBytes: MAX_PAYLOAD_SIZE })
+  } catch (error) {
+    if (error instanceof WebhookBodyTooLargeError) {
+      return NextResponse.json({ error: 'Payload too large' }, { status: 413 })
+    }
     return NextResponse.json({ error: 'Bad request' }, { status: 400 })
   }
 
-  if (rawBody.length > MAX_PAYLOAD_SIZE) {
-    return NextResponse.json({ error: 'Payload too large' }, { status: 413 })
-  }
-
   const verified = await verifyAndParse(req, rawBody)
   if (!verified.ok) {
     return verified.response