com.tipre.suite
├── TipreSuiteApplication.java
├── articulos
│   ├── ArticulosApi.java          ← público
│   ├── ArticuloSnapshot.java      ← público (record)
│   ├── StockDescontado.java       ← evento público
│   ├── api/                       ← @NamedInterface("api")
│   └── internal/                  ← invisible para otros
│       ├── ArticuloEntity.java
│       ├── ArticuloRepository.java
│       └── ArticulosService.java
├── promos
├── envases
├── pagos
├── ticket
└── shared
    └── package-info.java          ← @ApplicationModule(type = OPEN)

// articulos/package-info.java
@org.springframework.modulith.ApplicationModule(
    displayName = "Artículos",
    allowedDependencies = { "shared" }
)
package com.tipre.suite.articulos;

// ticket/package-info.java
@org.springframework.modulith.ApplicationModule(
    displayName = "Ticket",
    allowedDependencies = {
        "shared", "articulos", "promos :: api", "envases"
    }
)
package com.tipre.suite.ticket;

// articulos/ArticulosApi.java  (público)
package com.tipre.suite.articulos;

import java.util.Optional;

public interface ArticulosApi {
    Optional<ArticuloSnapshot> buscarPorEan(String ean, long sucursalId);
}

// articulos/ArticuloSnapshot.java  (público)
package com.tipre.suite.articulos;

import com.tipre.suite.shared.Money;

public record ArticuloSnapshot(
        long articuloId,
        String ean,
        String descripcion,
        Money precioUnitario,
        boolean pesable,
        long versionPrecio) {}

// articulos/internal/ArticulosService.java
package com.tipre.suite.articulos.internal;

import com.tipre.suite.articulos.ArticuloSnapshot;
import com.tipre.suite.articulos.ArticulosApi;
import java.util.Optional;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
class ArticulosService implements ArticulosApi {

    private final ArticuloRepository repo;

    ArticulosService(ArticuloRepository repo) {
        this.repo = repo;
    }

    @Override
    @Transactional(readOnly = true)
    public Optional<ArticuloSnapshot> buscarPorEan(String ean, long sucursalId) {
        return repo.findByEanAndSucursal(ean, sucursalId)
                   .map(ArticuloMapper::toSnapshot);
    }
}

// ticket/TicketCerrado.java  (evento público)
package com.tipre.suite.ticket;

import com.tipre.suite.shared.Money;
import java.time.Instant;
import java.util.List;
import java.util.UUID;

public record TicketCerrado(
        UUID eventId,          // idempotencia
        UUID ticketId,
        long sucursalId,
        int caja,
        Instant cerradoEn,
        Money total,
        List<Linea> lineas,
        int schemaVersion) {   // evolución del evento

    public record Linea(long articuloId, String ean,
                        long cantidadMilli, Money importe) {}
}

// ticket/internal/CierreTicketService.java
@Service
class CierreTicketService {
    private final TicketRepository repo;
    private final ApplicationEventPublisher events;
    // ctor...

    @Transactional
    public void cerrar(UUID ticketId) {
        TicketEntity t = repo.findForUpdate(ticketId);
        t.cerrar();                               // cambia estado
        events.publishEvent(TicketMapper.toEvento(t)); // se registra en la MISMA TX
    }
}

// articulos/internal/StockListener.java
package com.tipre.suite.articulos.internal;

import com.tipre.suite.ticket.TicketCerrado;
import org.springframework.modulith.events.ApplicationModuleListener;
import org.springframework.stereotype.Component;

@Component
class StockListener {

    private final StockService stock;
    private final ProcessedEventRepository processed;

    StockListener(StockService stock, ProcessedEventRepository processed) {
        this.stock = stock;
        this.processed = processed;
    }

    // = @Async + @Transactional(REQUIRES_NEW) + @TransactionalEventListener(AFTER_COMMIT)
    @ApplicationModuleListener
    void on(TicketCerrado evt) {
        // Idempotencia: el registro garantiza at-least-once, NO exactly-once
        if (!processed.marcarSiNuevo(evt.eventId(), "articulos.stock")) {
            return;
        }
        evt.lineas().forEach(l ->
            stock.descontar(evt.sucursalId(), l.articuloId(), l.cantidadMilli()));
    }
}

<!-- pom.xml -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.modulith</groupId>
      <artifactId>spring-modulith-bom</artifactId>
      <version>2.1.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.springframework.modulith</groupId>
    <artifactId>spring-modulith-starter-core</artifactId>
  </dependency>
  <!-- JDBC registry: recomendado incluso con JPA -->
  <dependency>
    <groupId>org.springframework.modulith</groupId>
    <artifactId>spring-modulith-starter-jdbc</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.modulith</groupId>
    <artifactId>spring-modulith-starter-insight</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.modulith</groupId>
    <artifactId>spring-modulith-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

# application.yml
spring:
  modulith:
    events:
      jdbc:
        schema-initialization:
          enabled: false   # en prod el schema lo maneja Flyway
      # UPDATE (default) | DELETE | ARCHIVE
      completion-mode: archive
      republish-outstanding-events-on-restart: false # ver slide multi-instancia
      staleness:
        # namespace 2.x: cuánto tiempo en cada estado
        # antes de considerarse fallido (ver reference doc
        # de tu versión para las keys exactas)
  task:
    execution:
      pool:
        core-size: 8
        max-size: 32
        queue-capacity: 2000   # ¡nunca ilimitado!
      shutdown:
        await-termination: true
        await-termination-period: 30s
  lifecycle:
    timeout-per-shutdown-phase: 40s

-- Una tabla por módulo (o una compartida con columna consumer)
CREATE TABLE articulos.processed_event (
    event_id     UNIQUEIDENTIFIER NOT NULL,
    consumer     VARCHAR(100)     NOT NULL,
    processed_at DATETIME2        NOT NULL DEFAULT SYSUTCDATETIME(),
    CONSTRAINT pk_processed_event PRIMARY KEY (event_id, consumer)
);

package com.tipre.suite.articulos.internal;

import java.util.UUID;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
class ProcessedEventRepository {

    private final JdbcTemplate jdbc;

    ProcessedEventRepository(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    /** true si es la primera vez. Corre en la TX del listener:
     *  si el negocio falla, el INSERT también hace rollback. */
    boolean marcarSiNuevo(UUID eventId, String consumer) {
        try {
            jdbc.update("INSERT INTO articulos.processed_event(event_id, consumer) VALUES (?, ?)",
                        eventId, consumer);
            return true;
        } catch (DuplicateKeyException dup) {
            return false;
        }
    }
}

package com.tipre.suite.ticket;

import org.springframework.modulith.events.Externalized;

// target :: routing key (SpEL) → particiona por sucursal en Kafka
@Externalized("pos.ticket.cerrado::#{#this.sucursalId()}")
public record TicketCerradoV1(
        java.util.UUID eventId,
        java.util.UUID ticketId,
        long sucursalId,
        java.math.BigDecimal total,
        java.time.Instant cerradoEn) {}

<dependency>
  <groupId>org.springframework.modulith</groupId>
  <artifactId>spring-modulith-events-kafka</artifactId>
</dependency>
<!-- o -amqp, -jms, -aws-sqs, -aws-sns -->

src/main/resources/db/migration/
├── __root/               ← infraestructura (event_publication, ...)
│   └── V1__event_publication.sql
├── articulos/
│   ├── V1__schema.sql
│   └── V2__stock_por_sucursal.sql
├── promos/
│   └── V1__schema.sql
├── envases/
├── pagos/
└── ticket/
    ├── V1__schema.sql
    └── V2__ticket_linea_snapshot.sql

package com.tipre.suite.config;

import java.util.concurrent.Executor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
class ExecutorsConfig {

    // Pool dedicado para integraciones lentas (fiscal, adquirentes)
    @Bean("integracionesExecutor")
    Executor integracionesExecutor() {
        ThreadPoolTaskExecutor ex = new ThreadPoolTaskExecutor();
        ex.setThreadNamePrefix("integ-");
        ex.setCorePoolSize(4);
        ex.setMaxPoolSize(8);
        ex.setQueueCapacity(500);
        ex.setWaitForTasksToCompleteOnShutdown(true);
        ex.setAwaitTerminationSeconds(30);
        ex.initialize();
        return ex;
    }
}

// Listener que usa ese pool en vez del default
@Component
class FiscalListener {
    @Async("integracionesExecutor")
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @TransactionalEventListener
    void on(PagoConfirmado evt) { /* llamar gateway fiscal */ }
}

• ApplicationModules.verify() en CI, bloqueante
• allowedDependencies declarado en todos los módulos
• Ninguna entidad JPA en APIs públicas ni en eventos
• Ninguna FK ni query entre schemas de módulos
• Todos los listeners async son idempotentes (con test de doble entrega)
• Eventos con eventId y versión; política de evolución escrita
• EPR con JDBC, schema por Flyway, completion-mode definido
• Job de reintento + purga + alerta de pendientes

• Executors acotados y separados para integraciones externas
• Timeouts y circuit breakers en toda salida HTTP
• Graceful shutdown probado con kill durante carga
• Procedimiento de deploy: drenar EPR antes de renombrar listeners/eventos
• Trazas por módulo y dashboard de latencia por módulo
• Feature flags por sucursal para cada flujo migrado
• Test de caos: matar una instancia en pleno cierre de caja
• Reconciliación de totales vs. sistema viejo en el piloto