feat!: a provider declares its dependencies by name

CLAUDE.md

@@ -598,9 +598,9 @@ label=com.btravstack.test-infra)` clears them), and testcontainers' own reuse
 namespace }` back off `Serving.info`. The Worker's lifecycle, the unit per
   attempt and the deadline race are the package's. It is a **two-slice
   modulith**: `FulfillmentSlice`'s `fulfillOrder = TemporalWorkflowActivities(orderContract,
-"fulfillOrder")([PlaceOrder, OrderRepository, StockService, ShippingService],
-{ sync })` and `BillingSlice`'s `chargeOrder = TemporalWorkflowActivities(orderContract,
-"chargeOrder")([PaymentService], { sync })` are each a **piece** — a provider
+"fulfillOrder")({ place: PlaceOrder, repository: OrderRepository, stock: StockService,
+shipping: ShippingService }, { sync })` and `BillingSlice`'s `chargeOrder = TemporalWorkflowActivities(orderContract,
+"chargeOrder")({ payments: PaymentService }, { sync })` are each a **piece** — a provider
   on the port its own contract key mints, closing over only the services its
   own saga calls, no context read at call time — and the root composes them,
   `orderActivities = TemporalActivities(orderContract)([fulfillOrder,
@@ -615,8 +615,8 @@ observability()] })`, the sugar importing the starter. `FulfillmentSlice`
   from the starter, and `LOG_LEVEL` and the `Logger` the sagas' stand-in
   services write to come from `observability()`. `order-amqp-worker` is the
   same shape — `NotificationsSlice`'s `orderNotifications = AmqpHandler(orderContract,
-"orderNotifications")([Logger], { sync })` and `AuditSlice`'s `orderAudit =
-AmqpHandler(orderContract, "orderAudit")([Logger], { sync })`, composed as
+"orderNotifications")({ logger: Logger }, { sync })` and `AuditSlice`'s `orderAudit =
+AmqpHandler(orderContract, "orderAudit")({ logger: Logger }, { sync })`, composed as
   `orderHandlers = AmqpHandlers(orderContract)([orderNotifications,
 orderAudit])` — but **neither** slice imports a vertical: a subscriber reacts
   to a fact somebody else already committed, so the orders vertical stays at
@@ -646,13 +646,13 @@ AuditSlice, observability()], … })`),
   (if it needs one) its own adapter, and ships as an ordinary di `Module` that
   exports only that piece's port — everything else about the slice stays
   private. `@btravstack/http`'s
-  `HttpController(name, fragment)([deps], { sync })` mints the controller's
+  `HttpController(name, fragment)({ name: Dep }, { sync })` mints the controller's
   port; the root composes every slice's controller into one router with the
   keyed `HttpRouter(contract)(controllers)` form, exact against the contract
   (see `packages/http/CLAUDE.md`). **A fragment is itself a valid contract**,
   so a slice lifts out of the modulith into a process of its own without its
   controller changing at all: the lifted root is
-  `HttpRouter(contract.orders)([ordersController.port], { sync: (implementation) => implementation })`,
+  `HttpRouter(contract.orders)({ implementation: ordersController.port }, { sync: ({ implementation }) => implementation })`,
   declaring the very provider the modulith composed and handing back what it
   built — a new composition root and one fewer import,
   not a rewrite of the slice. That exact call is `controller.test-d.ts`'s fifth

README.md

@@ -99,31 +99,34 @@ export const ordersContract = {
 import { HttpRouter } from "@btravstack/http";
 import { P } from "unthrown";
 
-export const ordersRouter = HttpRouter(ordersContract)([PlaceOrder], {
-  sync: (place) => ({
-    place: ({ errors }, input) =>
-      place
-        .execute(input.id, input.quantity)
-        .map((order) => ({ id: order.id, quantity: order.quantity }))
-        // The one place a domain error becomes a transport one — exhaustive,
-        // so a new domain error is a compile error here.
-        .mapErrCases((matcher) =>
-          matcher
-            .with(P.tag("InvalidQuantity"), (error) =>
-              errors.INVALID_QUANTITY({
-                message: error.message,
-                data: { id: error.id },
-              }),
-            )
-            .with(P.tag("DuplicateOrder"), (error) =>
-              errors.CONFLICT({
-                message: error.message,
-                data: { id: error.id },
-              }),
-            ),
-        ),
-  }),
-});
+export const ordersRouter = HttpRouter(ordersContract)(
+  { place: PlaceOrder },
+  {
+    sync: ({ place }) => ({
+      place: ({ errors }, input) =>
+        place
+          .execute(input.id, input.quantity)
+          .map((order) => ({ id: order.id, quantity: order.quantity }))
+          // The one place a domain error becomes a transport one — exhaustive,
+          // so a new domain error is a compile error here.
+          .mapErrCases((matcher) =>
+            matcher
+              .with(P.tag("InvalidQuantity"), (error) =>
+                errors.INVALID_QUANTITY({
+                  message: error.message,
+                  data: { id: error.id },
+                }),
+              )
+              .with(P.tag("DuplicateOrder"), (error) =>
+                errors.CONFLICT({
+                  message: error.message,
+                  data: { id: error.id },
+                }),
+              ),
+          ),
+    }),
+  },
+);
 ```
 
 ```ts

docs/examples/hexagonal-order-api.md

@@ -59,20 +59,26 @@ export const makePersistenceModule = () =>
   Module("Persistence")({
     imports: [ConfigModule],
     provides: [
-      Provider(Pool)([AppConfig], {
-        acquire: openPool,
-        release: (pool) => pool.close(),
-      }),
-      Provider(OrderRepository)([Pool], {
-        sync: (pool) => ({
-          findById: (id) => {
-            const row = pool.findById(id);
-            return (
-              row === undefined ? Err(new OrderNotFound({ id })) : Ok(row)
-            ).toAsync();
-          },
-        }),
-      }),
+      Provider(Pool)(
+        { config: AppConfig },
+        {
+          acquire: openPool,
+          release: (pool) => pool.close(),
+        },
+      ),
+      Provider(OrderRepository)(
+        { pool: Pool },
+        {
+          sync: ({ pool }) => ({
+            findById: (id) => {
+              const row = pool.findById(id);
+              return (
+                row === undefined ? Err(new OrderNotFound({ id })) : Ok(row)
+              ).toAsync();
+            },
+          }),
+        },
+      ),
     ],
     exports: [OrderRepository],
   });
@@ -103,7 +109,10 @@ export const makeAppModule = <E, N>(
   Module("App")({
     imports: [persistence],
     provides: [
-      Provider(GetOrder)([OrderRepository], { class: GetOrderInteractor }),
+      Provider(GetOrder)(
+        { orders: OrderRepository },
+        { class: GetOrderInteractor },
+      ),
     ],
     exports: [GetOrder],
   });

docs/examples/order-amqp-worker.md

@@ -57,26 +57,33 @@ name, since the contract key IS the port's name:
 export const orderNotifications = AmqpHandler(
   orderContract,
   "orderNotifications",
-)([Logger], {
-  sync: (logger) => (message) => {
-    const { id, payload } = message.payload;
-    if (currentUnit()?.signal.aborted === true) {
-      return ErrAsync(
-        new RetryableError(
-          `the drain deadline passed before order ${id} was notified`,
-        ),
-      );
-    }
-    logger.info(
-      payload === null ? "order gone — notifying" : "order placed — notifying",
-      {
-        orderId: id,
-        ...(payload === null ? {} : { quantity: payload.quantity }),
+)(
+  { logger: Logger },
+  {
+    sync:
+      ({ logger }) =>
+      (message) => {
+        const { id, payload } = message.payload;
+        if (currentUnit()?.signal.aborted === true) {
+          return ErrAsync(
+            new RetryableError(
+              `the drain deadline passed before order ${id} was notified`,
+            ),
+          );
+        }
+        logger.info(
+          payload === null
+            ? "order gone — notifying"
+            : "order placed — notifying",
+          {
+            orderId: id,
+            ...(payload === null ? {} : { quantity: payload.quantity }),
+          },
+        );
+        return OkAsync();
       },
-    );
-    return OkAsync();
   },
-});
+);
 ```
 
 The audit slice is the same shape over `"orderAudit"`, minus the deadline

docs/examples/order-api.md

@@ -156,7 +156,7 @@ import { ErrAsync, OkAsync } from "unthrown";
 
 import { HttpAuthenticator } from "./auth.js";
 
-export const bearerAuthenticator = HttpAuthenticator([], {
+export const bearerAuthenticator = HttpAuthenticator({
   sync: () => (headers) => {
     const header = headers.authorization ?? "";
     const token = header.startsWith("Bearer ")
@@ -189,9 +189,9 @@ use cases in [`order-application`](/examples/order-application), and the
 entities and Prisma adapters behind it.
 
 ```
-src/slices/orders/controller.ts       HttpController("OrdersController", contract.orders)([PlaceOrder, FindOrder, Logger], { sync })
+src/slices/orders/controller.ts       HttpController("OrdersController", contract.orders)({ place: PlaceOrder, find: FindOrder, logger: Logger }, { sync })
 src/slices/orders/module.ts           OrdersSlice — imports the vertical, provides the controller, exports only it
-src/slices/customers/controller.ts    HttpController("CustomersController", contract.customers)([FindCustomer], { sync })
+src/slices/customers/controller.ts    HttpController("CustomersController", contract.customers)({ find: FindCustomer }, { sync })
 src/slices/customers/module.ts        CustomersSlice — same shape as OrdersSlice
 ```
 
@@ -205,45 +205,48 @@ import { HttpController } from "../../auth.js";
 export const ordersController = HttpController(
   "OrdersController",
   contract.orders,
-)([PlaceOrder, FindOrder, Logger], {
-  sync: (place, find, logger) => ({
-    place: ({ errors, context }, input) => {
-      logger.info("order placement requested", {
-        userId: context.principal.userId,
-      });
-      return place
-        .execute(context.principal.tenantId, input.id, input.quantity)
-        .map(view)
-        .mapErrCases((matcher) =>
-          matcher
-            .with(P.tag("InvalidQuantity"), (error) =>
-              errors.INVALID_QUANTITY({
-                message: error.message,
-                data: { id: error.id },
-              }),
-            )
-            .with(P.tag("DuplicateOrder"), (error) =>
-              errors.CONFLICT({
+)(
+  { place: PlaceOrder, find: FindOrder, logger: Logger },
+  {
+    sync: ({ place, find, logger }) => ({
+      place: ({ errors, context }, input) => {
+        logger.info("order placement requested", {
+          userId: context.principal.userId,
+        });
+        return place
+          .execute(context.principal.tenantId, input.id, input.quantity)
+          .map(view)
+          .mapErrCases((matcher) =>
+            matcher
+              .with(P.tag("InvalidQuantity"), (error) =>
+                errors.INVALID_QUANTITY({
+                  message: error.message,
+                  data: { id: error.id },
+                }),
+              )
+              .with(P.tag("DuplicateOrder"), (error) =>
+                errors.CONFLICT({
+                  message: error.message,
+                  data: { id: error.id },
+                }),
+              ),
+          );
+      },
+      find: ({ errors, context }, input) =>
+        find
+          .execute(context.principal.tenantId, input.id)
+          .map(view)
+          .mapErrCases((matcher) =>
+            matcher.with(P.tag("OrderNotFound"), (error) =>
+              errors.NOT_FOUND({
                 message: error.message,
                 data: { id: error.id },
               }),
             ),
-        );
-    },
-    find: ({ errors, context }, input) =>
-      find
-        .execute(context.principal.tenantId, input.id)
-        .map(view)
-        .mapErrCases((matcher) =>
-          matcher.with(P.tag("OrderNotFound"), (error) =>
-            errors.NOT_FOUND({
-              message: error.message,
-              data: { id: error.id },
-            }),
           ),
-        ),
-  }),
-});
+    }),
+  },
+);
 ```
 
 Each leaf is the `.result()` handler `@unthrown/orpc` gives that procedure's
@@ -310,7 +313,7 @@ the recipe, and `packages/http/src/controller.test-d.ts` for the five gates
 that pin these errors and the lift below. Because a fragment is itself a valid
 contract, `ordersController` serves `contract.orders` alone unchanged: the
 lifted root is
-`HttpRouter(contract.orders)([ordersController.port], { sync: (implementation) => implementation })`
+`HttpRouter(contract.orders)({ implementation: ordersController.port }, { sync: ({ implementation }) => implementation })`
 over `OrdersSlice`, so extracting a slice out of this modulith is a new
 composition root and one fewer import, not a rewrite.
 
@@ -407,18 +410,21 @@ export class RequestSpan extends Port("RequestSpan")<{
 
 export const RequestModule = Module("Request")({
   provides: [
-    Provider(RequestSpan)([Logger], {
-      sync: (logger) => {
-        const startedAt = Date.now();
-        return {
-          finish: () =>
-            logger.info("request finished", {
-              durationMs: Date.now() - startedAt,
-            }),
-        };
+    Provider(RequestSpan)(
+      { logger: Logger },
+      {
+        sync: ({ logger }) => {
+          const startedAt = Date.now();
+          return {
+            finish: () =>
+              logger.info("request finished", {
+                durationMs: Date.now() - startedAt,
+              }),
+          };
+        },
+        onStop: (span) => span.finish(),
       },
-      onStop: (span) => span.finish(),
-    }),
+    ),
   ],
   exports: [RequestSpan],
 });
@@ -556,7 +562,7 @@ authenticator discharges the need. `HttpModule` compares the router's identity
 against the authenticator's itself, at the option:
 
 ```ts
-const wrongAuthenticator = HttpAuthenticator<{ readonly sub: string }>()([], {
+const wrongAuthenticator = HttpAuthenticator<{ readonly sub: string }>()({
   sync: () => () => OkAsync({ sub: "s-1" }),
 });
 

docs/examples/order-temporal-worker.md

@@ -55,21 +55,24 @@ declare is a compile error in that slice's own file, not a defect
 export const chargeOrder = TemporalWorkflowActivities(
   orderContract,
   "chargeOrder",
-)([PaymentService], {
-  sync: (payments) => ({
-    authorizePayment: (args, { errors }) =>
-      payments
-        .authorize(args.orderId, args.amount)
-        .map((authorizationId) => ({ authorizationId }))
-        .mapErrCases((matcher) =>
-          matcher.with(P.tag("PaymentDeclined"), (error) =>
-            errors.PaymentDeclined({ id: error.id }),
+)(
+  { payments: PaymentService },
+  {
+    sync: ({ payments }) => ({
+      authorizePayment: (args, { errors }) =>
+        payments
+          .authorize(args.orderId, args.amount)
+          .map((authorizationId) => ({ authorizationId }))
+          .mapErrCases((matcher) =>
+            matcher.with(P.tag("PaymentDeclined"), (error) =>
+              errors.PaymentDeclined({ id: error.id }),
+            ),
           ),
-        ),
-    capturePayment: (args) => payments.capture(args.authorizationId),
-    refundPayment: (args) => payments.refund(args.authorizationId),
-  }),
-});
+      capturePayment: (args) => payments.capture(args.authorizationId),
+      refundPayment: (args) => payments.refund(args.authorizationId),
+    }),
+  },
+);
 ```
 
 `fulfillOrder`'s own piece is the same activities record this example always