Coming from Laravel

effx gives a Laravel team a declarative surface it recognises: routes, request validation, policies, exception rendering, generated artifacts. The compiler reads that surface ahead of time and writes ordinary, inspectable Effect. You keep Effect's typed errors and requirements, and you can stop running the compiler and keep the output (ADR 0012, Generated code).

effx is not Laravel for TypeScript. It does not ship a container, an ORM, a queue, an authorization engine or a scaffolder. Where Laravel has a first-party package for something, this page names the Effect package that covers it, or says gap.

Version pin. Laravel claims on this page cite the Laravel 13.x documentation. The documentation index at laravel.com/docs listed 13.x as current on 2026-10-04. Links of the form laravel.com/docs/13.x/<page> redirect to laravel.com/framework/docs/13.x/<page>. Laravel's own first-party packages (Sanctum, Passport, Reverb, Telescope, Pulse) are documented on the same site.

effx claims cite a spec (spec 0005 is docs/specs/0005-http-contract-extension.md) or a source path. Effect claims cite the Effect v4 repository (packages/effect/src/..., ai-docs/src/...).

Concept mapCopy Anchor Link

Gaps todayCopy Anchor Link

These are things a Laravel team will look for and will not find in effx. None is called planned. Where a spec exists, it is cited.

• SQL persistence and migrations. @PersistentModel records facts. Spec 0008 (SqlProjection) is proposed, not frozen, and STATE.md parks it. examples/users keeps users in an in-memory Ref<HashMap> (examples/users/src/services.ts). Use effect/sql directly.
• Authorization evaluation. effx records the access declaration and requires a typed guard binding. It never resolves a credential, interprets a policy or chooses a principal (spec 0006). Cedar and leases are deferred past the MVP kernel (ADR 0007). A required binding is not proof the handler called it. The real security gate is the application's own journey.
• Authentication products. Nothing in effx or in the Effect clone issues tokens, manages abilities or revocation, or runs an OAuth2 server. Effect supplies the security scheme and middleware slot (HttpApiSecurity, HttpApiMiddleware), not a Sanctum or Passport.
• Jobs, queues, scheduling, caching, realtime. No annotation. The Effect packages in the table cover the runtime side.
• Scaffolding and generators. No make:*. The effx CLI compiles and inspects; it does not write source.
• Testing harness. No effx test helpers beyond the generated RPC layerTest.
• Implicit route model binding. There is no equivalent. The handler or a service loads the entity and fails with a typed error such as UserNotFound (examples/users/src/services.ts).
• Problem Details builder. effx ships no RFC 9457 envelope. Http.Problems calls a registry function that your application exports. Domain-error to problem conversion and ProblemBoundaryLive are hand-written (spec 0005).
• Validation error shape. There is no 422 error map by default. A failed decode is an empty 400 (HttpApiSchemaError) until you transform it.
• Application-wide middleware. There is no annotation. Middleware attaches per operation or through a group default. For app-wide behaviour use raw Effect (effect/http), which can coexist in the same program (ADR 0012).
• Maturity. Evidence for access, problems and the client is compiler and fixture level. The mono-web migration gates in STATE.md are separate and several are unlanded. Treat this page's port as a design translation, not a production claim.

Port one endpointCopy Anchor Link

The endpoint is PATCH /users/{id}/email, for an authenticated user:

1. The body is { "email": "..." } with a format rule and a length limit.
2. Only the user themselves may change their email. This rule is invented for the page. The effx example does not state who may change an email.
3. An unknown user returns 404 and an email held by another user returns 409, both as JSON problem-style bodies.

All code below that is not an include is pasted and illustrative. It was not compiled, generated or run for this page. The effx snippets follow fixtures that the repository tests (named under each block).

use App\Http\Controllers\UserEmailController;
use Illuminate\Support\Facades\Route;

Route::patch('/users/{user}/email', [UserEmailController::class, 'update'])
    ->middleware('auth:sanctum');

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class ChangeEmailRequest extends FormRequest
{
    public function authorize(): bool
    {
        // The policy check. `user` is the bound User model from the route.
        return $this->user()->can('updateEmail', $this->route('user'));
    }

    /** @return array<string, array<int, string>> */
    public function rules(): array
    {
        return [
            'email' => ['required', 'string', 'email', 'max:255'],
        ];
    }
}

namespace App\Policies;

use App\Models\User;

class UserPolicy
{
    public function updateEmail(User $actor, User $target): bool
    {
        return $actor->id === $target->id;
    }
}

namespace App\Http\Controllers;

use App\Http\Requests\ChangeEmailRequest;
use App\Http\Resources\UserSelfResource;
use App\Models\User;
use App\Services\UserDirectory;

class UserEmailController extends Controller
{
    public function update(ChangeEmailRequest $request, User $user, UserDirectory $users): UserSelfResource
    {
        return new UserSelfResource(
            $users->changeEmail($user, $request->validated()['email']),
        );
    }
}

namespace App\Services;

use App\Exceptions\EmailAlreadyTaken;
use App\Models\User;

class UserDirectory
{
    public function changeEmail(User $user, string $email): User
    {
        $other = User::where('email', $email)->where('id', '!=', $user->id)->first();

        if ($other !== null) {
            throw new EmailAlreadyTaken($email);
        }

        $user->email = $email;
        $user->save();

        return $user;
    }
}

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class UserSelfResource extends JsonResource
{
    /** @return array<string, mixed> */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'email' => $this->email,
            'displayName' => $this->display_name,
        ];
    }
}

namespace App\Exceptions;

use Exception;

class EmailAlreadyTaken extends Exception
{
    public function __construct(public readonly string $email)
    {
        parent::__construct("The email {$email} belongs to another user.");
    }
}

use App\Exceptions\EmailAlreadyTaken;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Http\Request;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

->withExceptions(function (Exceptions $exceptions): void {
    $exceptions->render(function (EmailAlreadyTaken $e, Request $request) {
        return response()->json([
            'type' => 'https://example.com/problems/email-taken',
            'title' => 'Email already in use',
            'status' => 409,
            'detail' => $e->getMessage(),
        ], 409)->header('Content-Type', 'application/problem+json');
    });

    $exceptions->render(function (NotFoundHttpException $e, Request $request) {
        if ($request->is('api/*')) {
            return response()->json([
                'type' => 'https://example.com/problems/user-not-found',
                'title' => 'User not found',
                'status' => 404,
            ], 404)->header('Content-Type', 'application/problem+json');
        }
    });
})

How the layers line upCopy Anchor Link

Source for the effx column: spec 0005, spec 0006, packages/compiler/src/generate/{http,guards}.ts, docs/specs/0006-access-contract-extension.md §"HTTP lowering and guard interface".

What the port preservesCopy Anchor Link

• The route, the method and a declared bearer-protected contract.
• Validation of params and body at the boundary, before handler code runs. Params and body are decoded in HttpApiBuilder before the handler is called (packages/effect/src/http-api/HttpApiBuilder.ts).
• Three outcomes with fixed statuses: 404, 409 and 403. Unlike Laravel's render closures, each is a typed member of the operation's error channel, so the generated client (DeclaredFailures in client.ts) and the OpenAPI document see them.
• The service's typed failures. examples/users/test/e2e.test.ts asserts EmailTaken through the generated RPC client.

What the port does not preserveCopy Anchor Link

• Access evaluation stays application code. effx records the Http.Access declaration and requires a typed authorize binding. It does not run the policy, resolve the token or pick the principal (spec 0006). A required binding is not proof that the handler called it, and the real gate is the application's own journey. Cedar and leases are deferred (ADR 0007). In Laravel the framework calls FormRequest::authorize() for you before the controller. Here the handler must call authorize() itself.
• Problem responses follow spec 0005, not RFC 9457. Http.Problems imports your registry and emits error: Registry(...). The registry above only attaches statuses to the existing error classes, so the 409 body is the encoded form of the EmailTaken schema, not the type, title, status, detail body of the PHP version. To emit RFC 9457 bodies the application writes that derivation, as spec 0005 describes for mono-web. effx has no Problem Details builder, and ProblemBoundaryLive is hand-written.
• Validation failures differ. Laravel returns 422 with an error map. A failed decode here is an empty 400 until you transform HttpApiSchemaError.
• No route model binding. Laravel returns 404 before the controller runs. Here the service fails UserNotFound inside the handler, after the guard.
• Persistence is not the same. The PHP service checks and then saves, so only a unique index stops a concurrent writer. The effx example does both in one atomic Ref.modify on an in-memory store that does not survive a restart (STATE.md, Deferred notes). Neither is a port of SQL behaviour.
• Response wrapping. Laravel wraps the outermost resource in data by default. The effx response is the schema-encoded User.Self.
• Dropped exposures. The protected variant is HTTP-only. @Rpc and @Cli would need the guard argument too.
• Wiring changes. AppRoutes becomes AppRoutes(guards). The security marker needs a Layer.
• Unverified here. The pasted effx snippets were not compiled or built for this page. Run effx build and the TypeScript check on your copy to confirm. If the declaration and the handler disagree, the compiler reports EFFX2201 or EFFX2202 (errors), EFFX2205 or EFFX2206 (problem mapping), or EFFX2503 (a protected operation without a security marker).

Where to go nextCopy Anchor Link