CodeBooster
Get the kit free

Changelog

Every release, and what changed in it. Versions follow semantic versioning: the major number moves when an upgrade needs work from you, the minor when something is added, the patch when something is fixed.

2.9.1 latest

A patch release for the bundled generator client, which now trusts the generator's answer far less. It writes a generated module only into the folders a module lives in, never follows a redirect, and no longer seeds a production database on its own. Generated modules are unchanged. No migration. After upgrading run composer install, which picks up the updated client.

Security

  • The generator client writes only where a module lives. A generation's files are accepted only under app/, database/factories/, database/migrations/, database/seeders/, lang/, resources/js/, routes/ and tests/, plus the client's own config/crud-modules.php. Dotfiles and dot-folders (.env, .git/, .github/), absolute paths, .. and backslashes are refused, and so is writing through a symlink. A response naming any other path is refused as a whole before anything touches the disk, so a generator server, or anything between it and your machine, that was tampered with cannot plant a git hook, an .env, a composer.json or a config file in your project.
  • No automatic seeding in production. After a generation the client used to run db:seed --class=RoleSeeder --force. It now runs the seeder without --force, and when the application environment is production it does not run it at all: it prints the command to run once you have reviewed the change.
  • Redirects are never followed. A redirect would re-send your licence key or token to wherever it points; the client now treats one as an error, and follows the generator's own result link only on the same origin.

A minor release for the work a module does beyond create, edit and delete. Declare a business action on the command — make:crud invoices --action="mark-paid:fields=paid_at" — and it arrives with its own permission, Action class, button and dialog, route, API endpoint and tests. --singleton makes a module that holds one record for the whole application, and the reorder hint lets a list be put in order by hand. API refusals without a reason of their own now speak the application's language, and the generator can no longer hand over unformatted files without saying so. The kit's placeholder mark is the CodeBooster cube. No migration. After upgrading run composer install, which picks up the bundled generator client's new options; the new features reach a module when it is regenerated (make:crud … --force, or crud:upgrade).

Added

  • Custom actions on a record: make:crud --action="mark-paid:fields=paid_at,when=status:unpaid", once per action. Each gets its own permission and policy method, an Action class that runs under a row lock and files an audit entry, a button and dialog on the record's page and in the row menu, a web route and an API endpoint described in the OpenAPI document, and tests in the module's test file. fields= asks for columns in the dialog, when= offers the action only in some states (409 otherwise), sets= writes fixed values, bulk adds it to the bulk bar, no-confirm and danger change how it asks. crud:upgrade keeps a module's actions, and crud:remove takes them with it.
  • One record for the whole application: make:crud company_profiles --singleton. The menu opens that record's page, or the empty list to create it from; once it exists New is no longer offered and a second is refused (409, the API too), and it is never deleted.
  • Rows put in order by hand: the reorder hint on a whole-number column (position). The list opens in that order, and while it shows that order (sorted by it, nothing filtered) a row is dragged into place by its handle, moved with the arrow keys on the handle, or moved with Move up and Move down in the row menu. The rows of one page swap the places they hold, under a row lock and as one audit entry; a new row takes the last place; the API has POST /api/v1/<table>/reorder. The list component (DataTable) takes the new reorder prop for lists of your own.

Changed

  • The kit's own mark is the CodeBooster cube on its terracotta tile: the placeholder logo on the sign-in screens and in the sidebar, drawn without a second box around it (white on the sign-in panel), and favicon.svg, favicon.ico and apple-touch-icon.png. A logo set in Settings → Application, or through BRAND_LOGO and BRAND_FAVICON, still replaces it, in the same boxes as before.

Fixed

  • A generated module can no longer arrive unformatted without a word. The generator names a missing Prettier, ESLint or Pint and the command that installs it, reports a file Prettier could not format with Prettier's reason, and the generator server refuses a job it cannot format instead of sending the files as they were written.
  • An API refusal that gives no reason of its own (403, code: forbidden) now says so in the application's language, as a missing record already did; a policy's own reason is still sent as written. This covers the 403 that hides a record the caller may not see.

A minor release for planning a schema and for the records an office keeps. crud:plan shows what the generator would make of a table, or of the whole schema, before anything is written or a licence slot is spent, and crud:upgrade regenerates every recorded module after one preview. Generated modules gain document numbers (sequence:), a reason for a workflow move and separation of duties (reason:, not-by:), a row's photo on the list, and fixes from real projects; they take effect when a module is regenerated (make:crud … --force, or crud:upgrade). One migration, the number_sequences table (php artisan migrate). After upgrading run composer install, which picks up the bundled generator client's new commands. Production compose now builds Postgres from docker/postgres/Dockerfile; an existing database volume is unaffected.

Fixed

  • Generated modules, from their next regeneration (make:crud … --force):
    • searchable on a number, a date, a yes/no or a key to another table is set aside with a warning, instead of a search the database refuses on every term or an index page that does not compile. A key is already searched through its filter.
    • The generated tests import every helper and action they call: a master-detail module or a module with a workflow no longer fails its own suite on a missing use.
    • The test that a deleted record still holds a unique value also sends the columns the value is unique within (unique:<column>), so it collides as intended. Such a text column gets a value of its own in each test payload, so two records a test makes no longer collide.
    • The generated tests also prove that a workflow's stamp (stamp:<column>=<value>) stays empty on a move into another state and is written by the Update action, that a bulk status move answers for one row as for several, and that a bulk reassignment passes over locked records.
    • A hidden column named like a secret (pin_hash, api_token) is kept out of the model's serialization (#[Hidden]), so no JSON, prop or log line carries it; the generated test checks it stays out.
    • display on a foreign key names the row by the row the key points at, instead of an index page that read a key the row does not carry and did not compile.
    • A module without create (--except=create) may hide a NOT NULL column without a default: its rows are the application's to write. Its tests post no upload for a file column the form leaves out (no-form), and only a module with create gets the duplicate tests.
    • The bulk status request has a hand-written block (customRules()) kept across a regenerate, for a rule such as a reason to reject.
    • An open edit form saves over a change to a column it does not write, such as a stock count the application keeps or a touch of updated_at: the version it holds covers the columns the form writes (EDITABLE on the model). The API's ETag still covers the whole record.
    • A sidebar icon whose name ends one already imported (SmartphoneIcon beside MonitorSmartphoneIcon) is imported, instead of a sidebar that did not compile.
    • A rowTitle() an earlier generate wrote is no longer reported as hand-written, with a .bak, when the next generate does not emit it.
    • The number-bounds test leaves out a column the create form does not show (no-create), and the update test renames a text column, never an upload, a password or an encrypted value.
    • A level module (--scope) gets no loop guard, and no test of one, on a parent that always sits on another level.
    • Each module test starts by checking that its table is empty, so rows a migration inserts are named once instead of putting every count in the file off by them. Reference data belongs in a seeder.
    • A tree's path names each parent by the column marked display.
    • group:<column> on a column that is itself a key heads each group with the row it points at, not its id, and a key recording who approved a row (approved_by) no longer counts as a parent for group.
    • A route added to an existing module route file keeps the file's indentation.
    • "Sortable without an index" counts an index that starts with the scope column or a tenant key filled from the session, such as (tenant_id, number).
    • A CHECK that orders two dates (ends_on >= starts_on) becomes the matching date rule, and the factory and the generated tests keep the order.
    • A relation panel on a record page reads the child's keys into other tables as the rows they point at (a review's customer, a member's person) in the slots its own columns leave free. A link table with no name of its own is shown by those rows. The API sends the same columns as before.
    • A table with no naming column of its own, such as a link table of keys, is named by the rows its keys point at ("Ana Silva · Spouse") on its list, record page, delete dialog and activity log, instead of its id.
    • A workflow's stamp is filled on a factory row whose state is given as an enum case (->create(['status' => Status::Final])), as it is for the value as text.
  • The generator client installs alongside Guzzle 8 as well as 7.
  • The sidebar lists every screen of a module under its section, such as a hand-written page that shares a generated module's permissions; only the first one showed.
  • Production compose (compose.prod.yml, compose.coolify.yml): Postgres is built from docker/postgres/Dockerfile with the application role's script inside it, instead of a bind-mounted script a platform without the repository (Coolify, Dokploy) mounted as an empty folder — the database came up without the application's role and every migration failed. Nothing changes for a running database: the script only runs on a new volume.
  • The test suite pins the brand settings (BRAND_*) as it pins the locale, so a brand set in .env no longer fails the brand tests; the hard-coded text check no longer reads a :placeholder as a word of the sentence around it.

Added

  • crud:plan asks the generator what make:crud would decide for a table — its title, search, filters and order — which column hints are worth adding, with the comment to write for each, and what it would warn about; --as plans it under the module name you will generate it as. crud:plan --all plans the whole schema: what each table becomes, the order to generate the modules in with the command for each, which are already generated here, and the licence slots the rest would take. A plan writes nothing and costs nothing.
  • crud:upgrade regenerates every module recorded in config/crud-modules.php, in the order it was made and with the options it was made with: per module it shows the files that change and the lines they gain and lose, flags a module that loses far more than it gains, and writes only after one yes (--dry-run stops at the preview, --yes skips the question). A module that would take a slot again this period is named and agreed to before anything is generated. Upgrade the kit first (make upgrade) for a newer generator.
  • Planning for agents on the codebooster MCP server: plan-app plans the whole schema in one call, plan-module takes advice: true for the hints worth adding, and generate-app generates a list of modules in order with one approval — the agent passes the exact number of new licence slots you agreed to, every module is planned before any is written, and the list stops at the first that fails.
  • A row's photo on the list and on its page: a module with a single image column shows its thumbnail beside each row's name on the index, and on the detail page in place of the initials. The row carries the picture's path for that; no table column is added. From the module's next regeneration.
  • Document numbers (sequence: hint): sequence:[seq4]/SK/[roman]/[yyyy] numbers each record as it is created — 0007/SK/XI/2026 — for the web, the API and imports alike. The number stays off the form and the request, is read-only in the API and never changes on an edit. The run starts again on the smallest date in the pattern (day, month or year); sequence-by:<column> keeps a run per value of that column, and a tenant column the session fills or a --scope module keeps its own. Two saves at once never draw the same number, and a save that fails gives its number back. The counters live in a new table, number_sequences (run php artisan migrate); App\Support\Numbering\Sequence draws them for your own code too.
  • A reason for a move, and separation of duties, on a workflow: reason:<state> asks a move into that state for a reason — a dialog on the record page, 422 without one — and keeps it on the move's audit entry; reason-in:<column> also writes it to a column shown on the page. The bulk Set status leaves those states out. not-by:<column> keeps the user that column names (whoever submitted the record) from moving it into an approve: state, super-admin included: 403, and the button stays visible, disabled, with the reason beside it. From the module's next regeneration.
  • public-id hint for an identity number that is public where it is used, such as an official's staff number printed on the letters they sign: the personal-data check no longer asks for it to be encrypted.

Patch release, and the one to install: 2.7.1 was not published. Upgrade from 2.7.0 straight to this release; everything listed under 2.7.1 comes with it, including its upgrade steps (composer install, npm ci, and on Docker a rebuild of the app image).

Fixed

  • Guzzle stays on 7.16. The Composer update in 2.7.1 had moved it to Guzzle 8, which the bundled generator client does not support yet. Laravel 13 supports both.

A patch release for security updates. The Docker image moves to FrankenPHP 1.13.4, Laravel to 13.42, and the remaining Composer and npm packages to their latest minor and patch releases; the theme no longer stops the app from starting in a browser that blocks site storage. No migration. After upgrading run composer install and npm ci; on Docker rebuild the app image (docker compose build app && docker compose up -d) — the base image changed, so that build starts from scratch. If you run the browser tests, run make e2e-setup once: Playwright 1.65 uses a newer Chromium than the one already in its volume.

Security

  • FrankenPHP 1.13.3 → 1.13.4, a security release. Its Docker image ships a Brotli patched against CVE-2026-111497, and it fixes seven FrankenPHP advisories, one of them high (a request that crashed the process in worker mode). PHP stays 8.5.12.
  • phpseclib 4.0.2 → 4.0.3, pulled in by Socialite: an unbounded PBKDF iteration count in encrypted-key parsing allowed CPU exhaustion (GHSA-w3p9-g4p2-h3rr). composer audit reports nothing; npm audit still reports the three low-severity findings through swagger-ui-react's deepmerge, which has no fixed release yet.

Changed

  • Laravel 13.36 → 13.42, with Inertia 3.7, Fortify 1.42, Sanctum 4.4, Reverb 1.13, spatie/laravel-permission 8.5 and twelve other Composer packages; 42 npm packages, among them React 19.3, Inertia 3.11, TipTap 3.33, Tailwind 4.3.5, Vite 8.3.6 and Playwright 1.65.

Fixed

  • The app starts in a browser that blocks site storage. use-appearance.tsx read and wrote localStorage without the guard public/js/theme-init.js already had, so a blocked store threw before the app mounted, and switching the theme threw too. It now falls back to the choice the server wrote from the cookie, in the same order as theme-init.js.
  • The search button and the account menu are named by what they show (WCAG 2.5.3, Label in Name, which axe-core 4.14 now checks). The search button was named "Search" while showing "Search… ⌘K", and the account button "My account: <name>" while showing the initials and the name, so a voice user who said what they saw reached neither. Both now take their name from their own text, with a screen-reader copy while only the icon shows.
  • make help no longer says that running Pest directly wipes the development database: phpunit.xml and tests/bootstrap.php force the testing database on their own, and the line now says what scripts/test.sh still adds.
  • DummyUserSeeder reports progress through $this->command?->, as Laravel 13.42 types a seeder's command as nullable.

A minor release for running in production and in more than one language: /health answers 200 on a production install, mail settings saved in the app reach the queue, password-reset forms no longer reveal which addresses have accounts, Indonesian installs get Indonesian reset and verification mail, and a Coolify deploy works from the shipped compose file. Settings › Security gains the account's own security history. Generated modules gain ten fixes from real projects; they take effect when a module is regenerated (make:crud … --force). No migration. After upgrading run composer install and npm ci (security updates to Symfony and npm packages); on Docker rebuild the app image (docker compose build app && docker compose up -d app). ⚠️ An empty CSP_IMG_EXTRA in production now means OpenStreetMap's tiles; write CSP_IMG_EXTRA="'self'" to allow no extra host.

Added

  • Settings › Security shows the account's own security history: the five latest sign-ins and changes to how the account signs in (event, browser and platform, address, time), and the whole history on settings/security/activity, grouped by day, filtered to sign-ins or account changes, 25 a page. It reads the activity log the kit already writes, so there is no migration.
  • activitylog.timeline_roles names roles, besides super-admin, that see the activity card on a record's own page. It is read by role name, never by permission, and ships empty, so nothing changes until you name one.

Changed

  • The browser-session list shows this device first and five rows; the rest open behind "Show more devices".
  • The generator and the store moved to codebooster.dev. The default CODEBOOSTERKIT_API in .env.example and .env.native.example is now https://crud.codebooster.dev, the portal link kit:remove-examples prints points at codebooster.dev/portal, and the support address in the README, LICENSE, SECURITY.md and THIRD_PARTY_NOTICES.txt is [email protected]. Projects that keep https://crud.codebooster.id in their .env need no change: the old address answers from the same generator.
  • .gitignore ignores the *.bak copies make:crud --force leaves beside a file it replaced; the bundled client's path repository pins its version, so composer.lock no longer changes with the branch you have checked out; .env.example says how to use a web font under the kit's CSP; init-app-role.sh says what a role you add yourself must be granted.
  • The README covers --show-extra (detail-page slots the generator never overwrites) and the new composer routes, which regenerates the route helpers with their forms; a BRAND_COLOR too pale to use is logged instead of ignored silently; the stamp hint's description names both partner pairs (_at/_by, _pada/_oleh); Tailwind no longer scans docs/, so the manual's examples stay out of the stylesheet.
  • The production app container runs pending migrations as it starts (RUN_MIGRATIONS, on by default, migrate --force --isolated), so a platform that deploys on git push, which never runs prod-deploy.sh, does not serve a release before its tables exist. Set it to false to run migrations yourself.

Fixed

  • The licence key example matches the key you are given. The README and the crud:login prompt showed a CBK- prefix that keys from the portal do not have, so a buyer who copied the example typed a key that was then refused. Both now show the key as the portal prints it.
  • make init survives one dropped lookup during the image build. A build that lost the network for a moment — a registry token, a base image's metadata — stopped the whole setup on the first try. The build is now tried once more after ten seconds when its error is a network one (a failed lookup, a timeout, a reset connection); any other failure stops at once with the explanation it had before.
  • /health no longer fails every production install. The "Optimized App" check also demanded a route cache, which the kit deliberately never builds (a route closure cannot be serialised), so /health answered 503 from the first deploy and an uptime monitor stayed red. It now checks the config and event caches only.
  • Mail settings saved in the app reach the queue. Queue workers read the mail settings when they start, and mail is sent from the queue, so a server set up on Settings › Mail kept sending invitations with the old settings until the workers happened to restart. Saving the settings now restarts them (queue:restart); Docker and supervisor bring them straight back.
  • Password-reset and verification mail, and the reset pages, read in Indonesian on an APP_LOCALE=id install. Laravel's own lines for them were never published: the forgot-password page showed the raw key passwords.sent, and the reset and verification emails, their greeting and their footer arrived in English. lang/{en,id}/passwords.php, pagination.php and lang/id.json now carry them.
  • Password resets can be switched off. A project that signs in through SSO only, and turns off Fortify's resetPasswords, no longer breaks: the auth pages take their form addresses from the server rather than importing reset routes that do not exist, the route test pins only the features that are on, and the users screen hides "Send password reset" (the action refuses it plainly instead of failing with a 500).
  • Deploying on Coolify (and other one-file hosts) works from the shipped compose file. The image build pins the drivers it boots Laravel with, so empty variables passed as build arguments no longer stop it at composer dump-autoload or npm run build ("Cache store [] is not defined"); CSP_IMG_EXTRA uses the :- form, which Coolify no longer misreads into USER_ID and GROUP_ID; an empty MAIL_PORT falls back to 2525 instead of failing every send with a TypeError. .env.prod.example now says that VITE_REVERB_* must be set by hand where prod-deploy.sh does not run, and docs/demo.md lists what to read back before the first deploy. ⚠️ CSP_IMG_EXTRA left empty now means OpenStreetMap's tiles; to allow no extra host write CSP_IMG_EXTRA="'self'".
  • VITE_AUTH_LAYOUT reaches the production image. It is a build argument of the assets stage and of both production compose files, so the auth page shell chosen in .env.prod.example is the one deployed rather than always the default.
  • Postmark and Resend say what they need. The production template names the package each transport requires; without it the first send failed.
  • The dashboard's "this month" delta compares like with like. It set the month so far against the whole of last month, so it read negative for most of every month and caught up only on the last day. It now compares with the same span of last month.
  • Outline buttons drawn as links keep their border. buttonVariants() now passes its classes through tailwind-merge, as <Button> always did; without it the base border-transparent won over the outline border on about ten screens (Cancel on the users and roles forms, security, settings) and on generated detail pages.
  • The roles chosen on the user form read as their names. The chips above the role list showed the stored key (super-admin) while the list showed "Super Admin".
  • The activity trail reads values the way the screens do. A decimal is grouped in the reader's language (5.000.000,00 in Indonesian, not 5,000,000.00), dates are dd/mm/yyyy with a 24-hour clock like every table and form, and an enum shows its label instead of its stored value.
  • The activity card on a record's page speaks the reader's language. Each entry is titled by what happened (Created, Updated, Deleted, Restored), from lang/*/activity-log.php, and the change list below it carries the detail. The stored English sentence stays what the Activity Log screen and its export show, since that is history.
  • Smaller screen fixes. A field label beside an image uploader sits at the top of its cell instead of floating to the middle; a dashboard chart's value axis is as wide as its longest label, so money ticks are no longer cut off on the left.
  • The kit's own tests stop tripping over a project's choices. HardcodedTextTest accepts an enum's label() strings however many words they have (they come from the schema's enum: hint, and schema names are not translated); EnvTemplateParityTest reads its "not in production" keys from seeding.env_not_in_production, so a project lists its demo keys there instead of editing the test; ImpersonationCandidatesTest no longer fails now and then with APP_FAKER_LOCALE=id_ID; and the rich-text test no longer reports a warning PHP's HTML parser raises inside Symfony.
  • Generated modules, from their next regeneration (make:crud … --force):
    • a foreign key that is not an integer, or past its column's range, is refused as a field error before the existence check, instead of a 500 from the database;
    • a picker's search reads the related rows through their model, so a project's global scopes (a tenant's rows, soft deletes) apply there as on the related module's own screens;
    • a key imported by name must match exactly one row: a name two rows share, or none, is reported on its line instead of linking to whichever row came first (ImportLookup);
    • encrypted on a hidden column the model fills writes the accessor that enciphers it;
    • a detail line's labelled enum is declared where the line reads it, so the module compiles;
    • factories fill a column that depends on an enum's value (show-if, a presence CHECK), so the example shop's coupons now carry their discount;
    • generated tests ask for filters.search only when the module searches, skip a column the hint makes required in the "left empty" case, and set the column a conditional key depends on.
  • Regenerating through the server never writes a stub over a project's widget. The client sends resources/js/widgets/*.tsx and keeps any write-once file (attribute labels, widgets, show-extra.tsx) that already exists; crud:login hides every group of a key but the last.

Security

  • Dependencies with published advisories are updated. The Symfony components behind fourteen advisories (html-sanitizer, http-foundation, http-kernel, mime, routing, serializer, yaml) and follow-redirects (high) move to fixed releases, and minimatch is held at a fixed release under typescript-eslint and the API docs viewer. composer audit reports nothing; npm audit reports three low-severity findings through swagger-ui-react's deepmerge, which has no fixed release yet. After upgrading run composer install and npm ci.
  • The password-reset forms no longer say which addresses have accounts. Asking for a reset link for an unknown address, or twice within the throttle window, now gets the same answer as a link that was sent, and the reset form reports an unknown address as an invalid link. Before, anyone could type addresses into either form and learn which belonged to a user.

A minor release for richer forms and larger data: a JSON column edited as key–value pairs or as rows, a foreign-key picker that adds the parent it is missing, a rich-text editor with tables, one table served as one menu per level, and a Tree that loads a level at a time. Generation now waits on the server without holding a connection open, and the client asks again when a connection never formed. One migration, for the example shop only (php artisan migrate). After upgrading run composer install and npm ci (new editor packages, a PHPUnit security update); on Docker, rebuild the app image (docker compose build app && docker compose up -d app), since every download in the build now retries. The new hints take effect when a module is regenerated (make:crud … --force).

Added

  • Tables in rich text. The richtext editor inserts a table with a header row and adds or removes rows and columns from its toolbar; the detail page shows it. Tab moves from cell to cell and, from the last cell, on out of the editor rather than adding rows.

  • Links in rich text are written in a dialog that checks them. The link button opens an in-app dialog instead of the browser's prompt. It accepts https://, http://, mailto: and tel: addresses and says so when it refuses anything else; with a link under the caret it edits or removes that link, and with nothing selected the address becomes the link's text.

  • A foreign-key picker can add the parent row it is missing. Hint the key creatable ($table->foreignId('category_id')->comment('creatable')->constrained();) and its picker — the plain select or the search — ends with Add Category. It opens the categories form over the one being filled, and the category it saves is selected straight away; nobody has to leave the form, create the category elsewhere and come back. The entry is offered only to users who may create a category, decided by the server. Generate the parent module after the hint is migrated: its store then also answers a JSON request with the new row (201 Created, a Location header and {id, label}), while an ordinary save still redirects with its toast. A cascade, a key with where:, a key to its own table and a parent without a generated module (users, roles) keep a plain picker, and make:crud says why.

  • One table, one menu per level: make:crud --scope=<column>:<value>. A hierarchy kept in one table — regions, its provinces, regencies, districts and villages told apart by level — becomes a module per level, each with its own menu, URL, permissions and API: make:crud regions --as=province --scope=level:province, then --as=district --scope=level:district and so on. Each module reads its own rows alone (a global scope on its model, App\Models\Scopes\<Model>Scope), files a new record under its value, and keeps the column off its screens. On the level column of a table that points at itself, a district's parent picker offers regencies only, each named by its path ("Bandung Regency · West Java"), the list filters by that parent with the same picker, the top level has no parent field, and with --relations a record's page lists the level below. The value must be one the column's enum: hint or CHECK allows, and a scoped module is only regenerated with its own --scope.

  • The Tree view of a large table loads a level at a time. A tree table of more than 2,000 rows when the module is generated now sends the top level with the page and the rows under each one as it is opened (a tree-children route, gated by the module's view permission); under a search or a filter it shows the matches with the rows above them. A 91,599-row regions table opens with its 38 provinces instead of a list cut off at 2,000. Smaller tables keep the tree they have.

  • A key into a one-table hierarchy may point at several levels: cascade:<column>=a,b,c. A facility owned by a district or a village is written cascade:level=district,village: the picker offers the rows of both, each named by its path, and the request accepts no other level. The single-level form is unchanged.

  • A JSON column edited as rows: the keyvalue and repeater: hints. A json or jsonb column was a text box for raw JSON on the form and raw text on the record page. Hinted keyvalue, it holds pairs of a key and a text value — a spec sheet, extra attributes — added and removed as rows and stored as one JSON object (App\Casts\KeyValueMap), at most 100 pairs in one save; each key is filled in, used once and at most 100 characters (App\Rules\KeyValueKeys), and the record page lists the pairs. Hinted repeater:label!,qty:int,price:decimal,done:bool, it holds rows of the sub-fields named — text, int, decimal, bool or date, ! for a required one — edited as a table where rows are added, removed, copied and moved, at most 100 of them. Each sub-field is validated by its type (a decimal within ±999,999,999,999,999, so a value past the float range is refused rather than failing the save), every save stores each value in its type whether it came from the form, the API or an import (App\Casts\RepeaterRows), the list shows how many rows a record holds, and the record page shows them as a table. Both travel through the export and the import as their JSON text, and the API documents them as an object and as an array of objects. A column without either hint is generated as before. Rows inside rows, uploads in a row and keys to other tables are not part of it: those want a child table.

  • The example shop shows the new hints. A product lists its specifications (products.specs, keyvalue), a shipping rate its price by weight (shipping_rates.tiers, repeater:), and the order form adds a shipping rate from its picker (orders.shipping_rate_id, creatable). One new migration, 2026_10_28_120000_add_showcase_columns_to_shop_tables; run php artisan migrate after upgrading. kit:remove-examples takes it out with the rest of the shop.

Security

  • PHPUnit 13.4.5 and Pest 5.3.4. PHPUnit 13.4.0 to 13.4.3 could let another local user run code through a shared temporary directory (GHSA-9vw2-f4vp). Both are development dependencies; composer install after upgrading brings them in.
  • The rich-text allow-list keeps tables, and nothing on them but how far a cell spans. App\Casts\RichTextHtml now keeps table, thead, tbody, tr, th and td. Every attribute on them is removed except colspan and rowspan, which stay only as a whole number HTML honours (1–1000 columns, 1–65534 rows). Event handlers, style, javascript: links and scripts nested in a cell are removed as they are everywhere else, and tests/Unit/RichTextHtmlTest.php proves each one. caption, tfoot and colgroup are unwrapped or dropped as before. tel: links are now kept as well as http, https, mailto and relative ones. The REST API description of a richtext field names the new tags; regenerate a module to refresh its OpenAPI document.
  • A link typed into the rich-text editor is checked before it is written. The browser prompt took any text, javascript: included, and the editor showed it as a link until the server stripped it on save.

Fixed

  • The rich-text editor follows its form, names itself, and shows its placeholder. A form that is reset, or loads another record, now shows the new value in the editor, which used to keep whatever it opened with. Screen readers hear a multiline textbox named by the field's label, a toolbar, and which formats are on (aria-pressed); the toolbar is one tab stop, moved along with the arrow keys, Home and End, and clicking the label puts the caret in the editor. The empty editor shows its placeholder: the style for it was there, but nothing ever set the text. FormField gives its label the id <id>-label, which the editor points at; in a form of your own, a <label htmlFor> naming the editor's id is given that id when it has none.
  • make:crud --force names a method you wrote beside the // crud:custom block, and keeps a copy. A method written next to the block rather than inside it was dropped by the regenerated model without a word. The command now names each method it is about to lose and leaves the old file beside the new one as .bak, as it already did for methods written before the markers.
  • make:crud --force names a factory method it is about to drop, and keeps a copy. A state() or helper written into a generated factory was overwritten without a word, while the README promised nothing written by hand disappears silently. The command now names each one, saves the old factory as .bak, and points at database/factories/Domain/<route>.php, the hook the generated factory reads and --force leaves alone.
  • A list column named like shared vocabulary labels its elements. A text[], multi-enum or multi-file column whose own name is in lang/*/attributes/00-common.php (jenis, kind) got no label for <column>.*, so a refused element was named by its raw key (jenis.0). Regenerating with --force appends the missing label.
  • A module with many columns comes out of make:crud lint-clean. Generated TypeScript was written in whatever order the generator thought of its imports and left to eslint --fix, which applies at most ten passes per file; a form importing some forty components came out with import/order errors still in it. The generator now writes every import block already ordered. Regenerating an older module may move an import type line next to its value import, or the // crud:form-imports marker above the route import — both are lint-clean.
  • Generated tests prove the bounds of a keyvalue or repeater: column. The create test now sends too many pairs or rows, an over-long key or value, an undeclared key, a blank required sub-field and a number past the float range, and expects each refused.
  • The generator client asks again when the connection never formed. On a link that drops some connections, make:crud failed on the first try with cURL error 28: Failed to connect. A connection that never forms sent nothing, so the client now tries three more times, 2, 4 and 8 seconds apart, and if the generator stays out of reach says that nothing was sent, no slot was used, and the command is safe to run again. A request that failed after it went out is not repeated.
  • The Docker build survives a network that drops connections. apt, every curl and npm retry a failed download (/etc/apt/apt.conf.d/80-retries, curl --retry 5 --retry-all-errors, NPM_CONFIG_FETCH_RETRIES=5) instead of failing the whole build on one dropped package. The NodeSource setup script is saved before it runs, so a cut download no longer hands half a script to bash. The first build after upgrading downloads everything once, since the base layer changed.
  • A test catches the inline handler that works in development and dies in production. The production Content Security Policy refuses onclick="…" and javascript: URLs, and refuses them silently; the development policy allows inline script for Vite, so the button works on your machine and does nothing on the server. ContentSecurityPolicyTest now reads every Blade view — print sheets and certificates included — and names any inline handler or javascript: URL it finds. Move the handler into a script file under public/js and attach it with addEventListener.
  • Reloading after a refused save no longer lands on a bare 405. A save turned away with 403, 419 or 429 showed the in-app error page with the save's own endpoint in the address bar (/orders/12/status); reloading it asked for a page that route only accepts as a write, and the browser showed the framework's "405 Method Not Allowed". The error page now keeps the address of the page the save was sent from (bootstrap/app.php).
  • The "Sign in as" grant picker offers only accounts it can grant to. Settings › Sign-in-as access searched every account, while the save accepts only one that holds the "Sign in as" permission through a role, is not a super-admin and has no access still running. On a fresh install only super-admin holds that permission, so every pick was refused on save. The picker now lists only the accounts the save accepts (settings/impersonation/candidates), and when there are none the screen says what an account needs, links to Roles, and points out that a super-admin signs in as anyone from the account menu.

Changed

  • The rich-text editor is TipTap 3, and it loads only with a form that uses it. The old editor was built on document.execCommand, which the HTML standard marks obsolete and which every browser carries out differently. RichTextEditor keeps its props, so generated modules work without regenerating; its code is a chunk of its own, fetched the first time a form shows the editor, while a page without rich text never downloads it. Added as exact versions, all MIT: @tiptap/react, @tiptap/pm, @tiptap/starter-kit, @tiptap/extension-link, @tiptap/extension-table and @tiptap/extension-placeholder, 3.32.0. Stored values are read as they are and change only when a record is saved from the form. What changes in a value the old editor wrote when it is saved again: <div> lines become paragraphs; <span> wrappers go and their text stays; <b> and <i> are written as <strong> and <em>; text sitting directly in a list item, or outside any block, is wrapped in a paragraph; and a list nested straight inside another list, as some browsers' editors wrote it, becomes part of the list item above it. No text is lost.
  • Signing in as another account works on the public demo. Demo mode refused it with the destructive actions, so the feature could not be shown. It locks nobody out — it changes only the visitor's own session, the borrowed account's sign-ins are untouched, and its security settings stay refused while it is borrowed — so config/demo.php no longer blocks it.

Documentation

  • README warns about throttle:N,1 without a prefix on routes you write. Every such route shares one counter per signed-in user, so a polled read route can exhaust the limit of an unrelated save. Use a named limiter or throttle:N,1,<prefix>. Generated modules are not affected; they use their own named limiters.
  • README explains why exec -e KEY=value does nothing in production. The production container caches its configuration at start, and a cached configuration no longer reads the environment. A one-off override runs a fresh container (run --rm -e); a lasting change goes in .env.prod followed by up -d.
  • README lists the factory hook among what survives --force. Values your business rules need belong in database/factories/Domain/<route>.php, not in the generated factory.

A patch release for uploads: a photo is stored without where it was taken, a form full of photos is no longer refused by the server's own limits, and the upload controls show what they hold. No migrations. Regenerate modules with an image or file column (make:crud … --force) to get the new controls. On Docker, rebuild the app image after the patch (docker compose build app && docker compose up -d app): the new limits live in docker/php/*.ini and the Caddyfile inside it.

Security

  • A photo is stored without its EXIF and GPS metadata. A phone writes where a photo was taken, and anyone who could open the stored file could read it back — a resident's house, a field officer's route. Every JPEG, PNG, WebP and AVIF upload is now rebuilt from its pixels when it is stored (App\Support\Files\RasterImage, called by StoredFiles::store()): the metadata is gone, the photo is turned upright first, and any bytes smuggled in beside the picture go with it. Other files are kept exactly as sent; GIF, BMP and HEIC are kept as sent too (GD cannot write them back the same). Photos stored before the upgrade are not rewritten.
  • The legacy .doc and .xls are no longer in what a file column takes by default. Both can carry macros. A column that needs them names them (file:doc,xls). Regenerate the module.

Fixed

  • A form with many photos is no longer refused by PHP. post_max_size was the same 50 MB as one file, so a gallery of 20 photos at 5 MB each could not be saved at once, and PHP dropped files past its default max_file_uploads of 20 without an error. The production image now takes 128 MB a request and 50 files (docker/php/php.prod.ini), Caddy refuses a larger body with 413 before PHP reads it, and a page answers 413 with the app's own error page and its reference instead of a bare exception.
  • A native install is told its upload limits. The guide for installing without Docker names the three php.ini settings and their values, and make doctor checks them — PHP's defaults (2 MB a file) refuse most photos before the app sees them.

Changed

  • Uploads in generated forms are drop zones that show what they hold. A photo is shown the moment it is chosen, large, with its name and size, a "New" mark, and a way to replace it or undo back to the saved one; a gallery is a grid with a count (3 of 20) and a remove button on each photo; a document is a row with its kind, name and size, and the saved one opens in a new tab. A file can be dropped as well as picked, and one of the wrong type or over the column's limit is turned away with its name before the form is sent (the server still checks content and name). The shared controls are in resources/js/components/upload; regenerate a module to use them.
  • The README names every file of yours that make:crud --force leaves alone. Besides the model and request crud:custom blocks, edited Actions and the language files, that is a module's form-hooks.ts, tests/Payloads/<route>.php, tests/Context/<route>.php and the widget files — and it says which generated files an edit made inside them is lost from.

A minor release: uploads that name the types and the size they take, QR codes and barcodes, the camera, totals under the table, and generator fixes. No migrations. One new setting, PERMISSIONS_CAMERA, closed by default. After the patch, run composer install and npm ci (three npm packages join, and bacon/bacon-qr-code, already installed with Fortify, is now required directly); on Docker, also rebuild the app image (docker compose build app && docker compose up -d app), since the camera's header is set by the Caddyfile inside it. Modules you generated pick up the entries marked "Regenerate the module" with make:crud … --force.

Added

  • QR codes and barcodes: the qrcode and barcode hints. A text column hinted qrcode, or barcode (Code 128, or barcode:ean13 / barcode:code39), is drawn on its record page as the code it is printed with — to download as SVG or print as a label — and scanned with the camera into its form field and into the list's search, so an asset is found by scanning its tag. A QR code is drawn on the server with the library Laravel's own two-factor screen uses; a line barcode is drawn in the browser. A scanned value is validated like a typed one (an EAN-13 by its check digit, App\Rules\Ean13), and a link it holds is never followed. The camera stays closed until PERMISSIONS_CAMERA=self (Permissions-Policy, as PERMISSIONS_GEOLOCATION); until then the scanner reads a photo of the code. Two npm packages join the kit for this: @zxing/browser with @zxing/library (reading, MIT and Apache-2.0) and jsbarcode (drawing, MIT).
  • An upload takes the types and the size its column names: file:pdf,docx,pptx and max-size:20MB. A file column took one fixed list up to 5 MB. It now names its own list from documents, images, audio and video (PowerPoint and LibreOffice files included) — never a type that could run on the server or in the page, so SVG, HTML and executables are refused at generate time — and its own limit, up to the 50 MB the server accepts. The picker offers only those types, and the generated tests send a file one kilobyte over the limit.
  • A PDF is shown on its record page. A file column that takes PDFs shows the stored PDF in the page, beside the download link, served inline from the file route as before.
  • An upload straight from the camera: the capture hint. On a phone, an image or file column hinted capture opens the back camera instead of the file browser — a document, a meter, an asset — and capture:user the front one, for a selfie at check-in. Desktop browsers keep the file picker. No security header changes: the phone's own camera app takes the picture.
  • Totals under the table: the sum and avg hints. A number column hinted sum or avg is totalled under its module's list — one line for the rows on the page, one for every row the filters match — formatted as the column's own cells are (money, cents, a percent, its decimals). The totals are worked out by the database from the same filtered rows as the table, kept with the tab counts when nothing narrows (so a save shows at once) and cached a minute per filter combination and per viewer scope when something does. The columns are declared once, in {Model}Columns::SUMMARY; the shared table component draws the lines (DataTable's summary). A hint on a key, an enum or a column that is not a number is reported, not applied.
  • Generated tests run inside a context your project defines. A module whose rows belong to the signed-in user's tenant, unit or branch could not pass its own tests: the actors and the factory rows were made outside any of them. Each generated test now runs tests/Context/<module>.php when the file exists — a Closure run before each test, or ['before' => Closure, 'after' => Closure] — the way tests/Payloads/<module>.php already adjusts the payloads. The file is yours; the generator never writes it. Regenerate a module to get the hook.

Fixed

  • A generated test no longer hands a derived column to an Action. The test payload carried every column, the model-filled ones included; a test that passes the payload to the Store action directly (the stamps tests) failed on a model that rightly refuses to have that column assigned. Regenerate the module.
  • Duplicating a record copies only what a second record may share. The copy left out the id, unique columns, files and the workflow status, but carried over a system: value — which the form then refused, so duplicating a VIP customer failed — the personal numbers in encrypted and sensitive columns (a tax id, a birth date) onto someone else's record, and the unique columns of a document's lines. And anyone who could view a record could open its copy: form-data?duplicate=1 now answers only a viewer the policy lets create (403 otherwise), as the Duplicate button already showed only to them. Regenerate the module.
  • Dropdown options and filtered totals are cached per viewer scope. A project that narrows rows per user registers a StatsScope resolver, and the tab counts were already cached per scope — but the options of a foreign-key dropdown, the values of a text filter and the total under a filtered table were cached once for everyone, so the first viewer's list (their records' names) and count reached every other viewer for up to a minute.
  • make init writes .env before it starts anything. It used to create the file after building and starting the containers, so a first run without .env started the stack under the default project name — and mounted the database volume of whichever project already used that name. It now also stops, naming the other folder, when containers from another folder already run under this project's name: two folders unzipped from the same bundle share that name until one of them sets COMPOSE_PROJECT_NAME.
  • A cascade:<column>=<level> key holds to its level when the levels are an enum: hint. The level column's values were read from a CHECK constraint only; declared in the column's enum: hint instead, the key accepted a row of any level — a province where a village belongs — and its picker offered every row. Regenerate the module.
  • An immutable status column gets no bulk "Set" action. The column cannot change once the row exists, but the bulk bar offered to rewrite it. Regenerate the module.
  • A composite unique: with a nullable partner treats an empty partner as empty. It was read as 0, which matches no row, so a second row at the top of a tree passed validation — and on a database whose unique index counts NULLs as distinct, such as MySQL, was stored. Regenerate the module.
  • The generated form-data test expects no parent label for a record without a parent. It expected an empty string where the response sends none, so a module with a nullable key into a large table failed its own test.
  • The combobox notice names the threshold, not a row count. "A combobox because the target table is large right now" printed the number of sample rows the generator's copy of the schema holds, not your table's size; it now says the table has more than 100 rows.

A patch release: four fixes, no migrations, no new settings. 2.4.1 was tagged but never released; everything it held is here.

Fixed

  • Running the test suite no longer deletes config/crud-modules.php. One of crud:remove's tests wrote its probe over that file and deleted it afterwards, as if a project never had one — but the generator client writes it on every generate, with the command of each module. In a project that had generated modules, ./scripts/test.sh removed all of those commands. The test now uses a configuration directory of its own. If your file went missing, git checkout config/crud-modules.php brings it back.

  • A detail page with the extra slots compiles on a table that links nowhere. make:crud --show-extra hands the page's permission helper to the slots (can={can}), but the helper and the auth it reads were removed whenever the page's own links asked no permission — on a table without foreign keys — and the module failed its closing check with Cannot find name 'can'. Regenerate such a module with --force; modules with links were not affected.

  • A duplicate in a table with row-level security is a field error, not a 500. A lost race on a unique column is answered with the same 422 the unique: rule gives, by reading the columns from PostgreSQL's DETAIL: Key (…) line. PostgreSQL leaves that line out when the table has row-level security — it would show a row the session may not read — so every such duplicate became a server error. The columns are now read from the index the message names, when the line is missing.

  • The bundle carries config/crud-modules.php for the example shop. The generator client records there the command each module was generated with, and an AI agent's list-modules reads it to regenerate a module with its own options. The bundle did not ship it, so the agent saw no example modules and the first generate in a new project added an untracked file. The upgrade patch leaves the file alone (see UPGRADING.md).

Generator server

Fixed on the server, for every kit version: regenerating a module whose table already holds rows no longer fails with value too long for type character varying(n) when the table has a short text column (char(1), varchar(3)). The first generate of a module, on an empty table, was not affected.

Security

  • PHP 8.5.12 in the image: PHP2Shell closed. The base image moves from FrankenPHP 1.12.7 to 1.13.3, which carries PHP 8.5.12. It closes CVE-2026-109618 and CVE-2026-109619, critical flaws that let an unauthenticated request execute code on the server; every image built from 1.12.7 had an older 8.5 and no setting mitigates it. 1.13 also brings Caddy 2.11.7 and the fixes for the FrankenPHP advisories published since 1.12.7 (GHSA-qcrp-8483-f2f2, GHSA-fq24-r53r-xcx3 and more). Rebuild your images after the upgrade — UPGRADING says how.
  • Builds no longer depend on PECL. redis (in the image every stage shares, production included) and pcov (development only) are built from their GitHub releases, checked against their SHA-256, instead of being fetched from pecl.php.net: when that registry answered 504 for hours on 2026-10-21, every build without a warm cache failed, deploys included. The extensions are built as before (redis with lzf, zstd and lz4).
  • Rich text is cleaned on the server. A richtext column used to keep whatever HTML it was sent: the detail page rendered it through an allow-list, but the edit form loaded it as it was and the REST API handed it out unchanged, so a script handler saved through the API or an import could run in the browser of whoever opened the form next, wherever no Content Security Policy blocked it. The model now casts the column with RichTextHtml (symfony/html-sanitizer), which keeps the editor's tags and drops everything else on write and on read; the editor loads a stored value through the same allow-list; the OpenAPI document says which tags survive. php artisan richtext:clean cleans the rows already stored and names any richtext column a model does not cast yet.
  • A workflow starts at its start. approve: guarded the moves into a signed-off state and locked: the records in a closed one, but creating a record took any state: whoever could create a review could create it already approved, and an order already delivered. A status with transitions: now accepts only a starting state on create — one no move leads to, or the column's default, never an approve:, locked: or system: state — through the form, the REST API and imports; the form offers only those, and a duplicate starts over from the default. The Store action still stamps a record that code past the form (a seeder, a job) creates already in a later state, and the generated tests prove both paths.
  • Dependabot watches the base image. It is pinned to the patch on purpose, so a security release reaches your project as a weekly pull request instead of never.

Kit

  • The upgrade patch leaves your README alone. It carried the kit's README, so every project that had written its own met a conflict there at each release that touched it. The kit's README of each release is in its bundle.

  • Ready for AI agents. The generator client carries an MCP server (php artisan mcp:start codebooster): an agent such as Claude Code, Cursor, Codex or Copilot plans and generates modules through make:crud, is refused a module that takes a new licence slot until you agreed, and never sees your key. A bundle ships .mcp.json with the server in it. Laravel Boost is a development dependency, and boost:install gives your agent the kit's guideline (.ai/guidelines/codebooster.md) and its codebooster-modules skill beside Laravel's. README → "With an AI agent", and the manual's new chapter 15; UPGRADING says what a 2.3.1 project does after the patch.

  • Personal data is protected by design, and an agent asks before it is not. The schema recipes' new §10 says which hint each kind of personal data needs — encrypted with a <column>_hash blind index for a NIK, KK, NPWP or passport, encrypted for health, religion, biometric, criminal-record data and a bank account (UU PDP No. 27/2022 Art. 4(2), GDPR Art. 9), password, sensitive for a birth date, mask:phone, private in a --public module — and the NIK, NPWP and KK recipes now keep the number encrypted. The agent's guideline, skill, MCP instructions and new-module prompt tell it to propose those hints with the column plan; plan-module and make:crud --dry-run name each column that looks personal, in English or Indonesian, without its hint; generate-module stops on one marked required until you chose to keep it (confirm_personal_data). The advice never refuses a generate from the command line.

  • Agents hear a generate's progress, and every tool says what it returns. generate-module runs make:crud in a process of its own and reports each step as an MCP progress notification; each tool declares its outputSchema. Codex stops a tool after 60 seconds: README and manual give its tool_timeout_sec.

  • A duplicate encrypted number is refused on its own field. An encrypted column is unique through its blind index, and a second record with the same NIK reported the error on nik_hash, which no form shows, so the save failed without a word. It is reported on nik.

  • Every hint documented, from the generator's own list. docs/hints.md describes all 62 hints with an example line each; 20 of them were missing from the README, which now carries the same table. Both, and the agents' skill, are written from one list that a test holds to the hints the generator reads, so a new hint cannot ship undocumented.

  • Schema recipes ship with the kit. docs/schema-recipes.md maps a field as people describe it (a price, a phone number, a status, a category) to the migration column and hints it needs; it had stayed behind with the generator. Agents read it through the MCP server (codebooster://schema-recipes) and show you the column plan before writing a migration.

  • A record's history shows a redacted date as redacted. A sensitive or encrypted date is kept in the audit trail as [redacted], and the history read it as a date: the record's page answered 500 after its first edit.

  • Embedded videos preview in development. CSP_FRAME_EXTRA allows https://www.youtube.com in .env.example, .env.native.example and compose.yml, so an embed column — the example products' video — shows its preview from the first run. Production still allows no frame host until you list one.

  • The brand can live in .env. BRAND_COLOR, BRAND_LOGO and BRAND_FAVICON supply the colour, logo and favicon while Settings → Application is empty — a fresh database, or a demo whose demo:reset would otherwise wipe the brand every half hour. Saved settings still win. The colour must clear the same 3:1 floor on both themes as the settings form, or it is ignored — quote it (BRAND_COLOR="#2563eb"), since an unquoted # starts a comment in .env; the logo and favicon take a public path, an https URL or a data:image URI. See config/brand.php and docs/demo.md.

  • The sign-in screen carries the brand. A brand colour that holds white text at 4.5:1 now fills the sign-in panel as it is, deepening toward the corner, where before every colour was mixed toward black and an orange came out brown; a lighter colour is still mixed, so the panel's text stays legible. The logo appears twice more: large and faint in the panel's corner, as a white silhouette whatever its own colours, and above the form's title from tablet width up. A logo on a transparent background silhouettes to its shape; one drawn on an opaque square silhouettes to a square.

  • A warm base, and the brand colour beyond the buttons. Settings → Application gains Base colour (BRAND_BASE in .env): zinc, the default and unchanged, or warm, the same roles on warm greys, measured to the same contrast floors. A brand colour now also tints the selected row and draws the charts in its own hue, a three-step ramp held at 3:1 against the card on both themes and both bases (App\Support\BrandChartRamp).

  • The placeholder mark is CodeBooster's. The sidebar, the sign-in screen and the favicon showed the Laravel logo until an install set its own; they show the kit's mark instead. The sidebar mark takes --sidebar-primary-foreground, so it stays legible on any brand colour.

  • The menus say what they are, and settings hold only settings. Three entries were called "Security"; they are now Security overview (the board under Audit & Security), Sign-in & security (your password, two-factor and passkeys) and Security policy. Settings keeps the Account group (Profile, Sign-in & security, Appearance, and API Tokens, which are the signed-in person's own) and the Application group (Application, Mail, Security policy). What an administrator checks day to day moved to the sidebar: System (System Health, Backups, Failed Jobs) and Administration → Sign-in-as access (the grants; the account menu's Sign in as… is the act itself). Permissions is a tab of Roles instead of a menu item of its own. In the top bar, Favourites has a star, and Presentation mode moved into the account menu. URLs and permissions are unchanged, so bookmarks and roles keep working.

  • The examples are one small shop instead of an HR list. Employees, Departments, Skills and Projects are replaced by a clothing store the generator built end to end, every module by make:crud with its hints in the migration comments: Catalog (Categories as a tree, Products with a photo gallery, a rich-text description, tags and an import, Product Variants, Tags), Sales (Orders with their lines and totals, a board by status, a calendar, a workflow that locks delivered and cancelled orders; Coupons whose fields follow their kind; Shipping Rates) and Customers (Customers on a map, Reviews with an approval step). The dashboard's department panel gives way to the shop's own five (below); the seeder fills about 480 orders over six months, rising, with today's share in the hours already gone rather than piled onto the last day. Each module's sidebar heading comes from make:crud --section, and PostgreSQL holds every enum column to its values with a CHECK constraint. kit:remove-examples still removes all of it — the modules, the eleven tables, the permissions, the seeder, the dashboard panels and the headings — and refuses while your own code names an example class or permission. The command behind each module is in config/examples.php, and on its pages (below).

  • The shop shows what the generator can do, not only the common part. Its migrations now use the hints a demo left unseen, each where a shop needs it: an order records when and by whom it shipped (stamp-once), one shipping rate is the default (single-active), the customer picker searches as you type (combobox), coupons are listed under their kind (group:kind) and the order list opens on the newest (sort:desc). A product's price needs its own permission to change (restricted), its form is in sections (section:), its slug follows its name (slug) and it carries a size chart (file). A variant's SKU is held to a pattern (regex:), one variant per size and colour (unique:), and variants are edited in the table (--inline-edit). A VIP's tax number is encrypted (encrypted), only a product on sale can be reviewed (where:), and a coupon's percentage is typed as one (mask:percent). A product belongs to a category under a department, picked by its path (cascade: into the tree, whose level the model fills — derived), keeps its cost out of the public API (private), plays a video (embed) and records who put it on sale (stamp:); a variant carries its measurements in a control of the shop's own (widget:). A coupon may apply to one product or one category (morph:), a customer's date of birth is kept to the record (sensitive), VIP is earned, not chosen (system:), the shop replies to a review once it is in (no-create), and the order list always shows the total (show). Coupons and Shipping Rates sit in one Checkout group of the Sales menu (--parent). Customer Sales, the tenth module, reads a database view: each customer's orders and revenue, read-only (--read-only, fk:).

  • A dashboard that reads like a product's. The example shop's five panels open it: Sales — revenue, paid orders and average order over the range, each with its change against the period before and a sparkline, and the variants running low as a link into the list filtered to them; Revenue by day with the period before drawn dashed beneath it; Orders by status as one split bar and a list, each status a link to its orders; Recent orders with the order list's own badges; Top products ranked by what they brought in. They live in app/Dashboard/Examples and resources/js/dashboard/examples, as the pattern for a project's own, and go with kit:remove-examples. The kit's panels follow: Users gets a heading of its own instead of two figures floating above it, sign-ups take two thirds of the row beside the roles, and the panels in a row now end on one line. The public building blocks grew to match — KpiCard takes an icon, a tone, a change in percent, a sparkline and a link; TimeSeriesChart draws the period before and names both lines; CompactTable takes decimal money, a cell of its own and columns left off a phone; WidgetPanel takes a "View all" link; ChangeBadge, Sparkline and SectionHeading are new — and DashboardRange gives the window before (previousStart(), previousEnd(), series(…, previous: true)) and change() in percent.

  • Each example page names the command that made it. A line above every example module's pages shows its one make:crud command, with a copy button and how to remove the examples; it can be hidden, and it disappears with kit:remove-examples, which now ends by printing the next step: crud:login, where the key is, and make:crud on a table of your own.

  • make lists everything, and a typo says so. make and make help print every target by group, the columns sized to the longest name. New: make crud-login, make crud ARGS="…" and make crud-remove for the generator. A first word that is no target used to succeed at nothing; it now names itself and points at make help.

  • Code reads as it is typed. Geist Mono joined -- into one glyph, so a command in a <code> showed products--as=product. Ligatures are off for code, kbd, pre, samp and .font-mono.

  • Comments follow Laravel's own standard. Every method in the kit and in what the generator writes opens with a Laravel-style docblock — "Display a listing of the resource.", "Get the attributes that should be cast.", "Run the migrations.", "Handle the Order "created" event." — with its @param/@return tags where the native types do not say it all. Internal finding codes, dates and "used to" history are gone from the shipped code, long explanations are cut to the decision and its reason, and the comments in lang/id are in English like every other developer comment. Code is unchanged; the comment density stays under 10 %.

  • make upgrade keeps removed examples removed. A patch created every file that was new in the release, so a release that changed the examples would have put them back into a project that ran kit:remove-examples. The bundle now lists what the examples own (kit:remove-examples --list, shipped as scripts/example-files.txt), the patch names those paths in its header, and upgrade.sh leaves them out where ExampleDataSeeder.php is gone, and says how many it left out. upgrade.sh also runs the patch's own copy of itself when the patch changes it, so a fix to the upgrade reaches the upgrade that ships it rather than the one after. The script you run for this release is still the old one: see UPGRADING.md for the one command to run after it.

  • crud:remove takes only the module's own enums. Its enums were found by name, so removing product also deleted ProductVariantSize, an enum of the product-variant module, and broke it. An enum whose name starts with a longer model that is still here is now left to that model. A --detail module's line model (OrderItem for Orders) and its factory now go with the module; left behind, they named a deleted model and failed PHPStan in a project that had just run kit:remove-examples. It no longer takes kit code whose name only contains the module's: removing order deleted the kit's MenuFavoriteOrderRequest and unwired its menu-favourites reorder route, because names were matched as substrings; they are matched as whole names now. Two runs in one process (Artisan::call) no longer share their lists of paths. crud:remove … --dry-run --paths prints the paths alone, one per line, for scripts.

  • The sidebar is denser. A row is 32px with a mouse (40px on a touch screen, unchanged for thumbs), rows sit 2px apart, and a group heading is 24px with 8px above it, so a sidebar with every group fits a laptop screen without scrolling. A collapsible heading kept its own 32px height because the label's classes were dropped when it rendered as a button; they now apply.

  • A map says when its tiles are blocked. The Map view showed a grey box when the Content-Security-Policy refused the tile server; it now says so and names CSP_IMG_EXTRA, as the form's location picker already did. Its empty state moved to the middle of the map, clear of the zoom control that covered it on a phone, and its strings are in both languages. CSP_IMG_EXTRA is documented in .env.example and .env.native.example.

  • make upgrade leaves a README you rewrote alone. The kit's README changes in most releases, and merging it into your project's own README was a conflict nobody asked for. A README still as shipped is updated like any kit file; a rewritten one is kept and named.

  • The e2e browser survives a recreated container. Chromium lives in a volume, and make e2e installs it (and its system libraries) whenever the container lacks them; make e2e-setup does it on its own.

  • On Linux the containers run as you. scripts/dev-init.sh writes your USER_ID/GROUP_ID to .env when they are not 1000, so the containers can write to the project folder; the image reuses a group ID it already has. macOS and Windows are left as they were.

  • scripts/test.sh runs without a terminal — from a git hook, a pipe or < /dev/null — and checks on the host that compose.coolify.yml is in step with compose.prod.yml, which the test inside the container could not.

  • Front-end dependencies past their advisories. npm audit is clean again: dompurify 3.4.17 (GHSA-cg2g-xh64-v4q7 and two more, critical), vite 8.3.5 (GHSA-9jrq-w75r-8gcw and four more, high) and vitest 4.1.12 (GHSA-qxg6-89mg-rqv8, moderate, development only); undici 7.30.1 under jsdom (GHSA-4qv8-2p9j-2685 and two more, high) and fast-uri 3.1.9 under ajv (GHSA-w74x-v6f9-j3xg and three more, moderate), both development only.

  • compose.coolify.yml passes the BRAND_* variables. It is generated from compose.prod.yml and had not been regenerated after they were added there, so a Coolify or Dokploy deployment ignored them.

Generator

  • A module named like an example is yours, whole. After kit:remove-examples, a module for customers, products, orders or another table the example shop also has was built on the example's files, which the generator's server still held: the model came back with the example's columns and relations, and the actions, requests and observer that matched the example's were left out, so the module did not compile. The server now generates in a kit without the examples you removed — all of them or some — and make:crud tells it which. Regenerate a module made this way.

  • The public-API tests check by design, not by chance. They made three to six rows and checked the ones publiclyVisible() happened to let through, so with a narrowed scope a check was skipped, or passed having checked nothing, about a run in three. They now make rows until the scope shows one and hides one, and say which of the two never came.

  • English money names are money. A discount, tax, commission, revenue, payment, refund or loan decimal is formatted as currency in the table, the parent's panel and the export, and seeded as an amount, as its Indonesian counterparts already were; a discount sat as a plain number beside a subtotal in money. A name that holds a share — tax_rate, commission_pct, pajak_persen — is not money. Regenerate to pick it up.

  • Hints are read as they are written. A word inside a key:value hint is no longer a flag: label:Payment status had made the enum the module's status column, and label:Filter by region had made a column filterable, because searchable and filter were matched as substrings. Flags may still share a segment (searchable display), and a word written after a value that cannot hold a space (validate:min:1 searchable) is now reported as not read. single-active is a known hint (it warned that it did nothing), sortable, which nothing read, is reported like any unknown word, and approve: without transitions: says so. Regenerate a module whose labels hold such words.

  • A stamp's partner is named in the schema's language. closed_by beside closed_at reads "Closed by", where it read "Closed At oleh"; ditutup_oleh still reads "Ditutup oleh".

  • A bulk reassignment holds to the key's where: and tree level, as the form does; it had accepted a parent the form refuses. The generated test picks a target the key may point at.

  • A composite unique no longer turns a wrong sibling into a 500. unique:product_id,color queried with the raw input, so a product_id that was not a number reached the database. The siblings are read by their type, and the sibling's own rule reports the error.

  • A module with a restricted column and an API compiles. The admin and self API controllers checked the permission through Gate without importing it.

  • An inline-edited cell's errors name the column. The shared labels gain field, the attribute an inline edit validates.

  • A polymorphic relation is named as Laravel names relations. applies_to_type gives appliesTo() and the props appliesToTypes / appliesToOptions, where it gave applies_to() and applies_toTypes; the type column's label: names the field on the form, the record and in validation, which still read "Applies To"; and a record of the wrong type is refused with Laravel's own validation.exists message rather than one that printed the column. Regenerate a module with a morph: pair, and rename calls to the old relation method.

  • A module whose only picker is a morph: pair compiles — its form options called Options without importing it — and a morph: target with no model is named when you generate, where it was dropped in silence, so a misspelt morph:Prodcut no longer passes for a module not generated yet.

  • A widget on a JSON column compiles. The detail page handed widget: the decoded value where the widget takes text; it gets the text, as the form does. Regenerate the module.

  • A generated test reaches a tree's level through its parents. For a cascade: key into a tree, the test made its category at the level asked for but with no parent, so a project whose model derives the level from the parent read it as a root, and the module's own tests failed. The row is made under as many parents as its level is deep. Regenerate the module.

  • A picker only where the form has one. A combobox key the form never shows — a stamp's _by partner, a no-form or derived key — still got an arm in the module's search endpoint, a label lookup on every edit form opened, and tests of both; for published_by the endpoint listed people's names to anyone who could view the module. Those keys now have none. The record page also stops loading the relation behind a cascade: key, whose path it reads in a query of its own. Regenerate a module with a stamp partner, or a no-form key into a large table.

  • The generated tests cover stamps, polymorphic panels and the whole ?include list. A stamp: column outside a workflow had no test; it now has one for a record born in the value and one for leaving it and coming back (for a milestone, for staying). The record page's polymorphic panel is filled like the others, ?include is asked for every relation it allows (each under its key, on the record and on the list), the edit form's key into a hierarchy opens on its leaf's path, and a document's replaced line is checked to the cent. A restricted money column is tested like any other, on the form and over the API; the files an API create sends are checked on the record and the disk; and a panel's delete is refused without the child's own delete permission and files the child's audit entry. Regenerate a module to get them.

  • derived, embed and database views say what they need. A derived column points at a static method marked #[Boot] in the model's crud:custom block, which sits beside a generated booted() where a second booted() would not; an embed column reminds you of CSP_FRAME_EXTRA, as a map does of CSP_IMG_EXTRA; a module read from a view is no longer advised to add indexes, which a view cannot hold.

  • crud:remove leaves the rest of a --parent group alone, where it took the group and its other modules' items with it, since the group links to its first item's page, and takes the group with its last module, a two-word one included, where the group's link to it stayed behind its import and the sidebar failed to render; a --parent group is listed under its modules' --section, where it fell to the default heading; a nested item and its group are titled through the label dictionaries, as a flat item and a section heading are, where they stayed English in every language. Removing a view module also takes its factory hook (database/factories/Domain/<module>.php), and the widgets a removed module's pages used are named, kept for any other module that uses them.

  • An edit form keeps rich text as rich text. The form's data came from the column set, which holds the list's and the export's view of a record — for rich text, its plain words. The editor therefore opened without the paragraphs and markup, and saving the form stored them away. The form now gets the stored HTML, and every generated module's tests check it, along with the list and multi-choice values the form already received as stored. Regenerate modules with a richtext column (make:crud … --force).

  • A board card shows what a record is worth and whose it is. A --kanban card carried its title and nothing else, and a column only counted its cards. A card now shows what the record is worth — its total (or grand_total, net_total, amount, value) where it has one beside a subtotal, the first money column otherwise — and its first related record, read null-safe since that record may be in the trash; a column head adds up the money, and reads as the status badges do (the enum: label). The card opens from the keyboard too. Regenerate a board module (make:crud … --force) to get it.

  • A grouped dropdown follows the enum's order. group:<column> on an enum: column listed its groups in the alphabet of the stored values (High · Low · Medium); they now follow the enum (Low · Medium · High). Regenerate the module to get it.

  • A group hint that cannot apply says why — next to combobox/cascade, on a target over 100 rows, or (plain group) on a target without exactly one parent key — instead of leaving the picker ungrouped in silence. The README shows both forms with a migration.

  • Maps show from the first run. CSP_IMG_EXTRA now defaults to https://*.tile.openstreetmap.org in .env.example, .env.native.example and .env.prod.example, so the example shop's Customers map and every map column draw their tiles without a line of setup; empty it if no module draws a map. A module that draws a map still reminds you of the setting, for a .env that predates it.

  • A picker grouped by a coded column heads each group with its label. group:industry on a foreign key lists the companies under their industry, but the heading printed the stored value (software) where every other screen shows the label (Software, or the name an enum:A=Aktif hint gives it). The heading now reads the same as the rest of the app. Regenerate a module with such a key (make:crud … --force) to get it.

  • A laptop shows a module's key columns, not its title alone. Column reveal sizes were fixed for the widest module (a 1024px and a 1152px table), so on a 1280px screen with the sidebar open — a table about 975px wide — most modules showed the title column and nothing else. Each column now carries the table width it needs (reveal: '896px'), worked out from the module's own columns in the order a reader needs them: statuses, then relations, amounts and dates. A narrow module shows everything on a tablet; a wide one shows what fits and keeps the rest for wider screens, without scrolling the table sideways. Hidden-by-default columns carry no size: turning one on in the Columns menu shows it at any width, as before. DataTableColumn.reveal is now a string (each page's own REVEAL_CLASS key). Regenerate a module (make:crud … --force) to get it.

  • The generated tests pass on more schemas. An immutable display column (a coupon's code) is no longer written by the update, concurrent-edit and PATCH tests, which the update rules drop; a number column behind show-if: is bounds-tested with its trigger set, instead of being excluded and passing nothing; and an import of a slug column sends a value already in slug form. Regenerate a module with such a column to get it.

  • A module's mutation score counts its own classes. The generated mutates() named namespaces, which Pest matches as prefixes, so ProductModuleTest was scored against the Product Variants module too. It now lists the module's own classes, read off the files the generator writes for it.

  • The generated tests test what the generator writes. A module that used a feature the old examples did not was tested for that feature's presence, not its contents. The tests now hold each rule to a value it refuses (a slug's and a rich text's length, a decimal's largest value, a coordinate's range, a gallery's lists and each file in them, a typed-in tag's name), fill a record page's relation panels and check the newest ten with their columns, check the board's columns, counts, sums and cards, the calendar's month, a combobox's search, the edit form's every key (optional keys filled, dates, the picker's label, the document's lines), a document's totals to the cent and its lines on the record page, each column an import is held to, a bulk request's thousand-row cap and what "all" means in the trash, a workflow move's audit entry and its 409, a column fixed once created on the form, and every relation the API embeds. On the example shop the mutation scores went from 50 % (Products) and 58 % (Orders) to above 80 %. Regenerate a module (make:crud … --force) to get them.

  • An observer for a gallery-only module passes PHPStan. The file clean-up after a delete filtered its paths with is_string(), which PHPStan level 8 calls always true for an image;multiple column; it is typed string now whenever no single-file column is nullable.

  • The view tabs fit a phone. A module with every view (Table · Board · Calendar · Tree · Map) had a 422px tab group on a 390px phone, so the page scrolled sideways. Below sm the tabs show their icons, each named for screen readers and with a tooltip; aria-pressed now says which view is on. Regenerate a module with a second view to get it.

Found by building a real CRM from the 2.3.0 buyer zip and generating its modules through the production generator. No migration and no new env key.

Upgrading needs two commands once (the packages move out of Docker volumes into the project folder): after the patch, docker compose up -d, then docker compose exec -u root app sh -c 'chown "$(stat -c %u:%g .)" vendor node_modules' and make composer install && make npm ARGS=ci. A fresh make init does this on its own. The old volume can go: docker volume rm <project>_vendor.

Generator

  • --kanban, --calendar, --map and the tree view compile again. Since 2.0.0 split the controller, the four views read the index through a method the split controller no longer had, and a module that asked for one failed its own verify step. They now share the index's query, and the conformance gate generates all four.
  • --kanban, --calendar or --map with no column hinted for it (tabs, calendar, map) now says so and names the columns that could take the hint, instead of quietly generating no view.
  • A whole-number column hinted mask:percent gets whole percentages from its factory. It got decimals, which PostgreSQL refuses in a smallint, and every test that made a row failed.
  • A tree cannot be made to loop. A key back to the module's own table (parent_id) kept a record and the records under it out of the edit form's parent picker, but the server did not check: an update, an API call or a bulk move could make a record its own ancestor, and the generated bulk test failed. The update request now refuses the record itself and anything under it, the bulk move leaves the new parent and the rows above it in place, and the module's tests cover both. Regenerate a module with such a key (make:crud … --force) to get them.
  • A module whose class another table already owns is refused before anything is written: activities would have become App\Models\Activity, the audit trail's model. Name it with --as or --model.

Development environment

  • Your editor resolves Laravel and React out of the box. vendor/ and node_modules/ are bind-mounted with the project, as Laravel Sail does it, instead of living in Docker volumes. Before, the host held two empty root-owned folders, and VS Code or PhpStorm marked every framework class and React type undefined. The containers run as your user, so the packages are yours. make init hands back folders an older install left owned by root.
  • The first npm ci no longer prints ERESOLVE overriding peer dependency: two dependencies of the API docs page still declare React 18 and are told about React 19 through overrides.
  • The GitHub Actions workflows ship with the current action releases, so a new repository does not open with a Dependabot pull request.

Tests

  • The content-security-policy test reads the page production serves, so the suite stays green while make dev runs.
  • An API-token test that failed when two tokens were created a second apart no longer does.
  • The README check applies only while the README is still the kit's: a project that writes its own README keeps a green suite.

The tests the generator writes catch more: a module's own tests now kill over 80 % of the mutants of its controllers, actions, requests and policy. No migration and no new env key. Upgrade from 2.2.0 with the patch, which also brings the example modules' new tests. Your own modules get theirs when you regenerate them (make:crud … --force).

Generator

  • A generated module's tests catch four changes in five. Run pest --mutate against a module's test file and it kills over 80 % of the mutants of its own controllers, actions, requests and policy: Employee 82.9 %, Department 82.6 %, Skill 80.3 % (51.6 % before). New tests cover:

    • every bulk action with one row and with none: the toast, the single audit entry with what it set, and the page counts it retires;
    • a required field left out of the request, not only sent blank;
    • the length cap of every text field, an e-mail address included;
    • an upload too wide, too large or of the wrong type;
    • a pivot list that is not a list, or names a row that does not exist;
    • a value left empty where the field is optional;
    • the record page's actions and pivot lists, the saved views on the index, the text suggestions, and what the edit modal is handed and what a duplicate drops;
    • import: the values stored, an empty sheet, a file that is not a sheet;
    • restore and delete-for-good of a row still live, and a unique value held by a deleted record;
    • an update's audit diff, and a delete through the API with a matching If-Match.

    Regenerate a module (make:crud … --force) to get them.

  • The generated controllers no longer pass ['count' => …] to trans_choice(), which fills :count itself. The import controller no longer retires the page counts: each imported row goes through the Store action, whose model events already do.

  • ./scripts/test.sh --mutate switches coverage on, which mutation testing needs. Score a module by its file: ./scripts/test.sh tests/Feature/EmployeeModuleTest.php --mutate --parallel. --group still loads every other module's mutates() and reports their classes as untested.

The one to install after 2.0.1: 2.1.0 was not published, and everything listed under it comes with this release. Upgrade from 2.0.1 straight to 2.2.0 with the patch. No migration and no new env key. If your project was installed without Docker, from .env.native.example, its .env names the wrong generator (the first fix below); make upgrade corrects it. Regenerate a module only to use the new hints.

Generator

  • Every Postgres range type is a type of its own. daterange had a control; tsrange, tstzrange, int4range, int8range and numrange fell through to text, so the factory wrote a sentence and the database refused the module's own test. Each is now a range literal ([2026-01-15,2026-02-01), either side open) with two inputs on the form and "from – to" on every screen. App\Casts\PostgresRange gives timestamp bounds one shape, ISO 8601 with the app's offset, whatever zone the database session runs in. App\Rules\RangeValue checks the shape, the bound types, the order and emptiness, so a bad range is a 422 rather than Postgres' 500. A filter on a range finds the rows that overlap a window (FilterSet::overlaps()). The OpenAPI document describes the literal with an example. A range is never searched, even when hinted searchable.
  • A document two people sign gives each signature its own permission. approve:agreed@agree,adopted on a state machine: moving into agreed needs <module>.agree, into adopted <module>.approve. Each is seeded, gets a policy method and an abilities flag, and the transition asks the one its target needs. The generated tests refuse each signature to an editor who holds every other. An ability the module already spends (edit, delete, …) is reported, and its state keeps approve.
  • locked-by:<key>.<key> carries a lock past the direct parent. A budget line hinted locked-by:kegiatan_id.apbdes_id freezes with the plan its activity belongs to, while the activity's other children stay open. The observer checks the old parent and the new one up the path, bulk writes leave such rows out, and a path that is not a chain of foreign keys to a locked: status is reported at generate time.
  • map:lng=<column> names a map's longitude, and bujur / lon / lng / longitude pair with the latitude without it. A column that does not exist is reported at generate time.
  • group:<column> groups a foreign key's options under a column of the parent (districts under their regency): the options are ordered by it and the picker shows the groups. A column the parent does not have is reported.

Fixed

  • An install without Docker is served the generator it bought. .env.native.example carried CODEBOOSTERKIT_KIT_VERSION=1.4.2 in every bundle, so a project set up from it asked the server for the 1.4.2 generator: no model written, every module test red. Each env template is stamped with the release now. If yours was installed from .env.native.example, set the line in your .env to this release, or run make upgrade, which does it.
  • ->comment() goes before ->constrained(). The cascade example put it after, where it lands on the foreign key's definition and the column gets no hint at all.
  • A date column shows as a date. formatDate('2026-01-15') printed 2026-01-15 as it came: the repair for Postgres' +07 offsets read the -15 that ends a date as one. A calendar day is now read on no clock at all, so it does not move a day west of UTC either.

Three schema hints for the generator, nothing to change in an existing project: tone: for a status value's colour, where: for the parent rows a foreign key may point at, and derived for a column the model fills. Upgrade from 2.0.1 with the patch; regenerate a module only to use them.

Generator

  • A status badge says what its value means, and the schema can say it outright. The vocabulary now knows a document's life — rancangan grey, ditetapkan / disahkan / diundangkan / berlaku green, dicabut / revoked / withdrawn red — and a tone: hint names the colour of any value the words do not cover: tone:ditunda=danger,arsip=neutral (success · neutral · warning · danger · info · settled). The table and the detail page read the same map. A tone name or value the column does not have is reported at generate time and ignored.
  • where:column=a,b holds a foreign key to the parent rows it may point at. A head of village picked from officials whose jabatan is kepala_desa or pj_kepala_desa, not from everyone: the select's options (Options::for(…, where: […])), the combobox lookup, the exists rule (->whereIn()), the import rules, the factory's parent and the generated tests all hold to it. A column the parent table does not have is reported and the hint ignored.
  • derived marks a column the model fills. Off the form, the FormRequest and $fillable; hidden is honoured on it though it is NOT NULL without a default — a hash, a running number, a value computed in a saving hook. make:crud names the derived columns and says where to fill them; the factory still fills them, so the module's store test is what fails until the model does.

Patch release, and the one to install: 2.0.0 was not published. Upgrade from 1.19.1 straight to this release; everything listed under 2.0.0 comes with it.

  • make upgrade never reports an upgrade it did not do. When a patch could not be applied — kit files here no longer as shipped, and no copy of the originals for the merge — git refused the whole patch, the script hid its error, said "Upgraded", and nothing had changed. It now names each file git refused and changes nothing, and it fails if a patch applied but changed nothing.
  • make upgrade … FROM=<bundle>.zip merges a project that changed kit files. The three-way merge needs the files as they were shipped; FROM reads them from the bundle of the version installed, without touching the tree. A file the kit deletes that you changed is kept and named.
  • Its error messages show. A failure printed the heading and stopped before the reason.
  • The dev image carries git, zip and unzip, so the upgrade script's own tests run in the suite instead of being skipped.

A major release: upgrading needs work from you. Read these before applying the patch.

  • Production needs DB_ROOT_PASSWORD. The bundled PostgreSQL's superuser and MySQL's root get a password of their own, and the application's database user is no longer a superuser. Add it to .env.prod; prod-deploy.sh refuses to start without it. An existing volume keeps its roles — see Security below for the two statements that demote the application's.
  • The admin API is named after its tables. /api/v1/employee is now /api/v1/employees, and route names follow (api.v1.employees.*). A client of the admin API changes its URLs; the public and self-service APIs are unchanged.
  • Regenerate your own modules with make:crud … --force (through the generator server, which serves 2.0.0): the controllers, policies, requests, tests and pages it writes have changed.
  • Two migrations run: the activity log moves to its v5 shape (old diffs are carried over), and every API token gets its own expiry (one issued under the old thirty-day ceiling keeps that end).
  • The dashboard is a list of widgets (config/dashboard.php); a project that replaced the dashboard page reads its figures from its widget's data.

1.19.2 was never published; everything prepared under that number is in this release.

Dates

  • Dates follow the interface language. English pages write the month as a word — 11 Oct 2026, 11 Oct 2026, 23:15 — because 11/10/2026 is October to some readers and November to others; Indonesian pages keep 11/10/2026. The date picker's box takes ISO 2026-10-11 on English pages. APP_DATE_STYLE=numeric or text sets one style whatever the language. What is stored does not change.

Dashboard

  • The dashboard takes the project's widgets. It was one controller and one 950-line page showing users, roles and the example departments, so a project that needed its own figures replaced both and fought every upgrade over them. It is now a list of widgets: a class per panel (App\Support\Dashboard\DashboardWidget — key, title, permission, span, and data(Request, DashboardRange)), listed in config/dashboard.php, drawn by the component registered under its key in resources/js/dashboard/widgets.tsx. Both files are yours and no patch touches them; the kit's four panels (users, sign-ups, roles, departments) are widgets in that list, to keep, reorder or drop. Widgets are filtered by the viewer's permission, one with nothing to show is left out, and the 7/30/90-day range now applies to every widget (DashboardRange::series() fills a day-by-day series). For a project's own: resources/js/components/dashboard has a KPI card with its change, a chart over the range and a compact table, money in cents read through the one formatter. The department panel is left out once kit:remove-examples has removed its models. The page's props are now widgets and range: a project that read stats, growth and the rest from the page reads them from its widget's data.

REST API

  • Every API of a module is named after its table, in the plural. The admin API took the module's screen name, so make:crud employees --as=employee --api answered at /api/v1/employee while the same module's self-service and public APIs answered at …/employees. REST names a collection in the plural, and an API is a contract with the apps that call it: the admin API is now /api/v1/<table-kebab> with route names api.v1.<table-kebab>.*, whatever --as or --route call the screens. A module wired under the old path is moved when it is generated again — the old lines are taken out of routes/api.php, not left answering beside the new ones. Breaking: clients of the admin API move to the plural path (the example modules: /api/v1/employees, /api/v1/departments, /api/v1/skills); the OpenAPI document and its tags follow.

  • A hand-written operation documents the headers it reads. #[Operation] had no way to say "this takes an Idempotency-Key header", and a FormRequest that merges the header into its data to validate it had the field documented as a body field no client sends. headers: now lists them; a header named after the field it is merged into takes that field's rule as its schema, and the field leaves the body.

  • The Postman export sends what the API takes. A multipart request sent a file as an empty text field, a list as one JSON string (which the array rule refuses), a boolean as the text false, left out a record's key said once for every verb of a path, and filled a coded field with string. Files are now file fields, a list is one key[] entry per item, a boolean is 1/0, path-level parameters are carried, and a field with a simple pattern gets an example that matches it (^[A-Z]{2}-\d{3}$ → AA-000).

  • The API document lists what the API sends and takes. Missing were: the X-RateLimit-* and X-Request-Id headers on every answer (and X-RateLimit-Reset on a 429); the paginator's meta.links; a file's real type (it said application/octet-stream for a PNG served inline); several sort keys at once (sort=-status,name); include=<rel>Count / <rel>Exists; and a contact. The rate limit was "60 requests/minute" in the text whatever the limiter said. Now each is documented, sort and include are comma-separated lists, the limit is API_PER_MINUTE (60) for the limiter and the text alike, and info.contact names the application. A count was accepted for any relation and printed for none: a list now counts a to-many relation (<relation>_count, <relation>_exists on each row) and refuses a count of a to-one relation with 400. An edit-only module's UpdateInput/PatchInput schemas were left out of the document; they are in it. Regenerate with --force.

  • The input schema says what the rules check. A regex: hint and date_format: were not in the document, so a client met a 422 for a value the document allowed; an upload's max (kilobytes) was written as maxLength; a int[] column came back as strings (["1","2"]) under a schema promising integers; and an ip column was documented IPv4 only though IPv6 is taken. Now regex becomes pattern (left out when it carries a flag a pattern cannot), digits/digits_between and date_format become pattern (several formats, any of them) or minimum/maximum, a file says At most N KB., an int[] column is cast PostgresArray::class.':int' and read as integers, and ip is documented as either family. Regenerate with --force.

  • A refused token is rate-limited too. Laravel authenticates a route before it throttles it, so a request with a bad or expired token was never counted — each one a token lookup anyone could repeat — and its 401 carried no X-RateLimit-* headers (OWASP API4:2023). The rate limit now runs first ($middleware->priority() in bootstrap/app.php: Laravel's own list with ThrottleRequests moved ahead of authentication), and the api limiter asks Sanctum for the token's owner itself, so a valid token is still limited per user and a refused one per address. A project whose routes/api.php predates this lists throttle:api before auth:sanctum.

  • Public ids find their row however a client spells them, and the public API keeps internal ids to itself. A ULID sent upper-cased — its specification makes it case-insensitive — was a 404 in the self-service and public APIs; a public module keyed by slug printed the ULID as id and then answered 404 to it; and a link to a table with no public key went out as the internal integer (department_id: 3, filter[department]=3), naming nothing a public client could fetch and counting the rows behind it. ULIDs are now matched case-insensitively, a slug-keyed module with a ULID answers to either, and the public API leaves such a link out (make:crud says which and how to add a ulid). An embed stays keyed by its include name. Regenerate with --force.

  • PUT replaces, PATCH changes what it sends. Both verbs reached one handler with one rule set: a PATCH naming one field was refused because the others were "required", a PUT leaving fields out kept their old values, a changed immutable field was dropped with a 200, and the document listed only PUT with the create body. Now a PUT is checked as the edit form is (a required field it leaves out is a 422), a PATCH checks and writes only the fields it sends — a field it sends whose rule reads another (a date range, show-if, a composite unique) is checked against the other as stored — and a changed immutable field is a 422 (App\Support\Validation\Unchanged); sent back unchanged it passes. Update<Model>Request gains formRules() (the whole-record rules, which the inline cell edit uses too). The OpenAPI documents describe PUT and PATCH separately, with <Model>CreateInput, <Model>UpdateInput and <Model>PatchInput in place of the one <Model>Input. Regenerate with --force; a client generated from the old document renames the input types.

  • A query the API cannot use is a 400, wherever it appears. An unknown include on a single record was ignored (the list already answered 400); per_page=2 served 15 rows while links.next still said 2; filter[department]=abc matched nothing and filter[active]=maybe was dropped, both looking like a real answer; an unknown image size was 422. Each is now 400 with code: invalid_query and a sentence naming it (PageSize::api(), Includes::requested(), FilterSet::acceptsValue()). The screen keeps dropping a value it cannot use. A filter on an integer key now treats a non-number as no filter on the screen, as it did a value outside an enum. Regenerate with --force.

  • A create says where the record lives, and a read can be revalidated. A 201 carried neither Location nor ETag, so a client built the record's URL itself and read it again before its first conditional write; and If-None-Match with the current ETag was answered 200 with the whole body. A create now answers 201 with Location and ETag (admin and self-service), and a show answers 304 with no body to the version the client holds — unless ?include embeds rows the tag does not version. The public API answers Cache-Control: public, max-age=60 (API_PUBLIC_MAX_AGE; 0 turns it off) with an ETag on each record, and stored files carry ETag and Last-Modified and answer 304. The OpenAPI documents list Location, ETag, If-None-Match, 304 and Cache-Control, and leave out shared parameters, headers and responses no operation uses. Regenerate with --force.

  • A body the API cannot read is answered 415 or 400, not 422. A write sent as text/plain or XML, with no type, or with JSON cut off mid-object was read as no fields at all and answered 422 with every required field "missing". EnsureSupportedBody (on the admin and self-service API groups in routes/api.php) answers a type other than JSON, a form or multipart with 415 and the types it takes (Accept-Post/Accept-Patch), and JSON that does not parse with 400 invalid_json. The OpenAPI documents list both on every create and update. A project whose routes/api.php predates this adds EnsureSupportedBody::class to those two groups.

  • Every API error is problem details (RFC 9457). Errors answered {"message": …} (and errors on a validation), the same body for every 403 whatever the reason, and a missing record's sentence named its model class (No query results for model [App\\Models\\…]) to anyone, the public API included. Every error from the admin, self-service and public APIs — wherever their prefixes put them — is now application/problem+json with type, title, status, detail, instance, a machine-readable code and the request_id; message and errors stay where clients read them. A 401 carries WWW-Authenticate: Bearer (with error="invalid_token" when a token was refused), a read-only token's 403 carries error="insufficient_scope", and a suspended account, the trash and a missing permission are told apart by code. The OpenAPI documents describe the Problem schema and give every operation a default response. A business refusal under a custom self-service prefix (API_SELF_PREFIX=storefront/v1) answered with a redirect; it answers JSON now. A client that checked for Content-Type: application/json on errors reads application/problem+json.

  • A browser client can read the API's own headers. config/cors.php exposed none, and a browser hides every header outside a short safelist from the calling script — so a web client could not read the ETag it must send back as If-Match, a 201's Location, a 429's Retry-After or the request id. They are exposed now (exposed_headers).

  • GET /api/v1/user answers who the token belongs to, and no more. It returned the user model as stored — the second factor's confirmation, the suspension, the last sign-in, the password's age. It now answers {"data": {"id", "name", "email"}} through CurrentUserResource, from a controller the API documents list.

  • An API page has a total order. The admin, self-service and public indexes ordered by the requested or default column alone, so rows sharing a value (a seeded batch's created_at, a status) could come back in any order under LIMIT/OFFSET: one row served on two pages, another on none. The primary key is now the last ordering, in the direction of the first, as on the screen. Nothing to regenerate.

  • The API answers create and update with the record as stored. The response was built from the model the request had just filled, so a multipart create or update — where every value arrives as text — answered "department_id": "1" where a read answers 1, and a strict client (Dart, Swift, Kotlin) failed to decode it. The record is read back first; the update's body and its ETag now describe that one state. Each module with a foreign key tests it.

  • Deleting a row other rows still refer to is refused with 409, not a 500. A module with no trash removes the row on delete, so a foreign key may refuse it — and the delete action did not catch that (only the permanent delete from the trash did), so the API, the screen and the bulk delete all answered 500. The refusal is now a sentence naming what still refers to the row: 409 Conflict on the API (the request is sound; the row's state refuses it), a toast on the screen. Every delete refusal, permanent ones included, answers 409 now rather than 422, and the OpenAPI document lists 409 on the DELETE of a module whose delete can be refused. Each such module tests it against a real foreign key. Regenerate with --force.

  • Sorting by a related row in the API no longer answers 500. A foreign key sorts by its related row's label, and the document lists it in sort — but the API handed the name to the database as a column, so ?sort=department (the public API's too, without signing in) was a SQL error. Related labels and declared ranks now order through the list's own ordering (FilterSet::orderByKey(), a correlated subquery so it stays clear of the public scope and the public keys), both ways. Each module with a foreign key tests both directions.

  • A self-service write cannot point at a row the public may not see. A foreign key sent by its public key was looked up without the related module's publiclyVisible() scope, so a shopper could attach an unpublished row by its ulid and read its name back through ?include=. PublicKey::toIds() now applies the scope where the model has one; such a key is refused as exists, like one that names nothing.

  • The lost-update guard holds under concurrency. If-Match was compared before the write and outside its transaction, so two clients holding the same version both passed, and the second silently overwrote the first; the web form's _version had the same gap. The Update and Delete actions now take the version the caller read (expected:), lock the row, compare and write against that one state, and refuse with StaleRecord — 412 on the API, the "changed elsewhere" toast on the screen. If-Match is also answered before the body is validated (RFC 9110 §13.2.2), so a stale write is 412 even when its body is invalid. The ETag is strong now and compared strongly (a W/ tag never matches); the update's body and ETag describe one state. API_CONDITIONAL_WRITES=required makes If-Match mandatory: a write without it is refused 428 (RFC 6585), and the OpenAPI document marks it required and lists 428. Each module tests the strong comparison, 428, 412 before validation, the ETag after a write, and the refusal inside the action itself. Regenerate with --force; an edited Update or Delete action needs the new ?array $expected = null parameter.

  • An API update no longer deletes the gallery or the links it does not mention. The document named a gallery's input gallery and a picker's skills, while the requests read gallery_new/gallery_existing and skill_ids/skill_new; and the update read a missing list as an empty one. A client that followed the document lost its uploads on create, and every update it sent deleted the record's gallery files from disk and detached every linked row. Now the document names the keys the requests read; on update a list left out stays as it is and an empty list clears it; and a gallery reads as [{path, url}], the path being what {column}_existing sends back to keep a file (the public API still lists URLs). The web form keeps its reading — it always holds every list, so there a list a multipart body dropped is an empty one. Each module's tests now check that every documented input key is one its requests read, and that an update without the lists leaves them alone. Regenerate API modules with --force; a client reading a gallery as URLs reads url.

  • Two API documents, hand-written operations in them, a Postman export. The OpenAPI document described the generated modules only, behind login: a sign-in, a checkout or a webhook written by hand was missing, and an app developer could read none of it. A controller method now declares its operation with #[App\Support\Api\OpenApi\Operation] — summary, documents, security (token, none, or a scheme from api.docs.security; stripe ships), responses — while the path and verb are its route's and the body its FormRequest's rules (RequestSchema), so the document and the code cannot disagree. There are two documents: admin at /api/docs, behind login, the whole API; public at API_PUBLIC_DOCS_PATH (api/public/docs), readable by anyone, with its own Swagger UI outside the app's layout: the --owner and --public modules and the operations declared for it. Both are checked against the OpenAPI Initiative's own 3.1 schema in the tests and in the generator's conformance run (new dev dependency ajv). php artisan api:postman admin|public writes either as a Postman v2.1 collection.

  • The OpenAPI documents are 3.1.1. They were 3.0.3; 3.1 is OpenAPI's current line and takes its schemas from JSON Schema 2020-12, so a schema in the document is a schema any JSON Schema tool reads. A value that may be null says so in its type — "type": ["string", "null"] — where 3.0 had nullable: true, which 3.1 ignores; a schema's example is an examples list; a file in a multipart body is a string with contentMediaType (and format: binary, which Swagger UI still looks for). A file rule's max: no longer turns into a maxLength: it is kilobytes. Generated ApiSpec classes are written this way; one generated before is read into the same terms when the document is assembled, so nothing has to be regenerated for the document to be valid. The tests check both documents against the OpenAPI Initiative's own 3.1 schema (kept in tests/Fixtures/openapi-3.1), every schema in them against the 3.1 dialect, with Ajv (tests/Support/openapi31.mjs), and the new dev dependency ajv replaces justinrainbow/json-schema, which stops at JSON Schema draft 7.

  • The public OpenAPI document is valid before there is anything in it. With no public module yet, its paths were written as [], which is not an OpenAPI document — Redocly and client generators refused the page a fresh install serves. An empty set of paths is {} now.

  • php artisan api:openapi admin|public writes either document as JSON, for a linter in CI, a client generator or a gateway. The generator's conformance run lints both with Redocly.

  • The public and self-service APIs speak in public ids. Their resources extended the admin one, so the integer id and every integer foreign key went out beside the ulid ("id": 25, "category_id": 8) and came back in — filter[category]=8, a bag item posted with product_variant_id: 277 — and a client could count the table. Now a record's id is its ulid (else the public API's --public-key), printed once; a foreign key is the related row's ulid or unique slug, out, in and in filters; an embedded row carries its own. Lists read the related keys beside each row in one query (Resource::keys(), the new App\Support\Api\PublicKey, ApiQuery::withKeys()); filters by FilterSet::belongsToKey(); the self-service API lists through a new Filtered{Models}::selfSet() (no owner, no trash) and its requests list their keys in KEYS, which PublicKey::toIds() turns into ids before the module's own rules (and the project's customRules()) check them; a key that names no row, or an integer, is refused as exists. A table without a public key keeps its integer, and make:crud warns. The admin API is unchanged. Regenerate --public/--owner modules with --force; clients that read ulid read id, and send related rows by their public id. (TL91)

  • Errors under the self-service and public prefixes are JSON. Only /api/v1/* and requests asking for JSON got JSON errors, so an app calling /api/storefront/v1/… without an Accept header got the HTML error page — a 404, a 429, a 500. The prefixes in config/api.php count too, through one check both exception hooks share in bootstrap/app.php (one of them had kept its own, api/v1-only, copy).

  • The API reference is Swagger UI over a valid OpenAPI 3.1 document. /api/docs renders the document with Swagger UI (Authorize, Try it out, filter by tag, operation ids) and offers it as openapi.json for Postman, Insomnia or a client generator. The document passes the Redocly linter. Each generated module now describes itself — openApi() on its API controller states the resource's fields (enums, formats, decimals as the strings Laravel sends, money in cents, read-only columns), the request's rules (required, lengths, bounds), the filters' types and the relations ?include may embed — and the document lists only the operations whose routes exist, with filter[...], sort, include, per_page and page/cursor as the endpoint reads them, ETag/If-Match, and 400, 404, 412, 422 and 429. Before, every module was documented with POST, PUT and DELETE, search/direction parameters the API does not read, and every table column, hidden ones included. Regenerate your API modules with --force to take this up; a hand-written API controller is still documented from its table. New dependency: swagger-ui-react (loaded on that page only).

Security

  • The application no longer connects to PostgreSQL as a superuser. The image made DB_USERNAME its superuser, with BYPASSRLS: a row-level security policy filtered nothing, and SQL injection reached the whole server (COPY … PROGRAM, server files, other databases). On a new volume the superuser is now postgres, with its own DB_ROOT_PASSWORD, and docker/postgres/init-app-role.sh makes DB_USERNAME a role that owns the application's database and nothing else — enough for migrations, trusted extensions such as pg_trgm, and the demo reset. MySQL's root takes DB_ROOT_PASSWORD too, instead of the application's password. .env.prod needs DB_ROOT_PASSWORD; prod-deploy.sh refuses to start without it. An existing volume keeps its roles; to demote the application's, once: docker compose -f compose.prod.yml exec postgres psql -U <DB_USERNAME> -d <DB_DATABASE> -c "CREATE ROLE postgres LOGIN SUPERUSER PASSWORD '<DB_ROOT_PASSWORD>'", then the same with -U postgres and ALTER ROLE <DB_USERNAME> NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE.
  • Issuing an API token asks for the password again, and is rate limited. A read-write token is the account's whole API reach, and the page issued one to anyone holding the session. The token screen now sits behind password confirmation (an external account confirms too, as on the security screen), and issuing is bounded like the password form (throttle:sensitive).
  • "Select all N matching" acts on the N matching, not on the whole table. Every list sent a select-all's filters flat (search=…, status=…) while the server reads them from filter[…], the convention every list URL uses — so the request named no filter, and a bulk delete, status change or reassignment on a filtered list reached every row the user could write. In the users screen and in every generated module. The filters are now serialised where every page hands them over (useBulkActions), so modules generated before this release are fixed by the upgrade without being generated again; an action's own value (status for a bulk status change) stays beside the filters instead of colliding with a filter of the same name; the users screen carries its addresses filter too. An end-to-end test reads the request a filtered select-all sends — the Pest tests had been written the way the server reads, and passed.
  • An API token lives exactly as long as it says. sanctum.expiration was set to 30 days, and Sanctum applies that ceiling from a token's creation whatever its own expires_at says — so a token issued from Settings → API Tokens for 90 or 365 days, or as "never expires", stopped working on day 30 while the list still promised otherwise. The ceiling is back to Laravel's null; every token is issued with its own expiry from api.tokens.lifetimes (30, 90, 365 days; 30 by default), and one that never expires is refused unless API_TOKENS_NON_EXPIRING is true. A project that sets SANCTUM_EXPIRATION_MINUTES keeps it as a ceiling, and the form then offers only the lifetimes that fit under it. Issuing and revoking go through actions that record the entry on the account's own timeline (with the scopes and expiry); revoking another account's token answers 404. Expired tokens are deleted a day after expiry (sanctum:prune-expired), and the health page's history is pruned to its configured days (model:prune) — neither was scheduled. Upgrading: a migration gives every existing token the end the old ceiling gave it — thirty days from creation, or its own expiry if sooner.
  • The audit trail records what an account holder changes about how the account is guarded. It recorded sign-ins and failed ones, but not a password changed in Settings or reset by link, an address changed, two-factor turned on or off, recovery codes made or spent, a passkey added or removed, or every other session signed out — so "who turned off 2FA on this account, and when?" had no answer. Each is now an entry on the account's own timeline, caused by its holder, with an event of its own (password-changed, password-reset, two-factor-enabled, two-factor-disabled, recovery-codes-regenerated, recovery-code-used, passkey-added, passkey-removed, sessions-revoked) to filter the activity log by; an address change carries its before and after. Never the secret itself. Fortify's, Laravel's and the passkey package's own events feed one listener; the password and profile forms and closing one's own account go through actions.
  • /health takes its secret as a bearer token, never in the URL. A monitor polled /health?secret=…, which every proxy writes to its access log and a browser keeps in its history. The secret now travels as Authorization: Bearer <secret> (RFC 6750 §2.1) and the query string is refused like a wrong secret — a 404. Upgrading: point your uptime monitor's request header at the secret. The package's unused health.secret_token key is gone.
  • Demo mode refuses again. Its guard read only can: middleware, and since the kit's controllers authorize with #[Authorize] it refused nothing: a visitor could force-delete, delete accounts and change the mail server of a public demo. It now reads both forms, matches policy abilities (forceDelete on any model, delete@User), and also refuses the routes that change the demo account itself — its password, address, two-factor and passkeys, which locked every other visitor out. Tested against the real routes, not stand-ins.
  • Production keeps what it writes. storage/app/private — a module's private uploads, database backups, queued exports — had no volume and was lost on every redeploy; it has one. Logs default to JSON on stderr (LOG_CHANNEL=json) instead of a file inside the container. Redis evicts only keys with an expiry (volatile-lru), so a full Redis drops cache entries, never queued jobs. The queue's retry_after (330 s) outlasts the longest job, which a second worker used to pick up and run again. Postgres is healthy when it answers on TCP, not while it is still initialising behind its socket.
  • Error tracking sends. sentry/sentry-laravel was installed and documented but no exception ever reached it; every reported exception now does (a no-op without SENTRY_LARAVEL_DSN).
  • A stored file keeps its own Content-Security-Policy, and the theme script is a file. Caddy replaced the default-src 'none' a downloaded file is served with, and the layout's inline theme script was refused by the kit's own script-src 'self' on every production page — a console error and a flash of the wrong theme. It is public/js/theme-init.js now, and a test keeps inline scripts out of the layout.
  • Health mail goes to someone, or nowhere. Notifications were on with no recipient; they are on when HEALTH_TO_ADDRESS is set. Inertia's server-side rendering is off unless INERTIA_SSR_ENABLED says otherwise — the kit ships no SSR bundle.
  • Smaller security fixes. The impersonation lock names the passkey routes as the package does (passkey., not passkeys.); closing one's own account deletes its passkeys and keeps no name in the audit entry; the profile form lowercases the address and ignores closed accounts, as the admin form does. The demo reset runs hourly multiples correctly for intervals of an hour or more.
  • Every setting the kit adds reaches production. compose.prod.yml passes the environment through an allow-list, and 26 of the kit's own settings were not on it — the API prefixes and rate limits, the export and import caps, the display timezone, the upload disk, the token ceiling: set in .env.prod, they never reached the application. They are listed now, each with its config default (an empty value would have replaced it), documented in .env.prod.example, and a test keeps the three in step. A database whose SANCTUM_EXPIRATION_MINUTES arrives empty still gets its tokens' expiry migrated.
  • Two-factor required of a role is required of its tokens. A token issued to an account whose role must use two-factor — before the rule, or by someone who never set it up — is refused 403 until the holder does. A password's age is not held against a token.
  • kit:remove-examples finishes the job. It removes the examples' permissions too, names all four tables it leaves, drops them with --drop-tables (instead of suggesting db:wipe, which drops everything), says so on a second run instead of announcing the removal again, refuses to run in the kit's own repository, and has make remove-examples and make remove-examples-check. Four shipped tests that named an example only in a string no longer trip its warning, and a test keeps every test that needs the examples in tests/Feature/Examples.
  • Pickers and file fields, finished. The combobox list is a listbox of options with the chosen one marked, and says "loading" and "no results" in the reader's language instead of in English. A file field can open a phone's camera (capture="environment") and name its button for what it asks for. A "last active" time is rendered after the page reaches the browser, so a project that turns on server-side rendering gets no hydration mismatch from it.
  • Smaller fixes from the review. A timestamp Postgres writes with a whole-hour offset (+00) is read instead of emptying the page, and a value that is not a date is shown as it came; dev-init.sh names the failures a second run cannot fix (Docker out of network ranges, a full disk, a taken port); the parallel suite collects coverage (--parallel --coverage exited 1 with none) and gives each worker 1 GB; the dev Postgres allows the locks a parallel run needs; PERMISSIONS_GEOLOCATION lets a project's pages ask for a location; the end-to-end suite uses the APP_PORT in .env; COMPOSE_PROJECT_NAME is documented; the Indonesian preset sets the display timezone, not the storage one; make:crud's check runs PHPStan again on a clean cache before calling a module broken; the hardcoded-text test reads kolom.* keys, Columns labels and report SQL as the names they are; the route sweep accepts a uuid-keyed module; the release build's suite runs on its own database, as it always claimed to; and the README covers the kit in a monorepo.
  • Coolify and Dokploy are documented and shipped. compose.coolify.yml, the single-file form those platforms take, and the script that generates it now come with the kit (docs/demo.md).
  • A queued export's file is deleted when its link expires. The user export mailed a link that worked for three days and kept the file — names and addresses — forever. exports:prune runs daily and deletes every export older than its link.

Tests and configuration

  • npm run build warns about what you can act on. Every build, dev-init's included, ended with Vite's "chunks larger than 500 kB" over the entry chunk and swagger-ui. React and Inertia now build into a vendor chunk of their own, which stays cached across deploys and leaves the entry under the limit, and the warning is a 500 kB budget per chunk in vite.config.ts that leaves out only swagger-ui — loaded by the API reference page alone.
  • Tests of a page live under resources/js/tests/. The Inertia Vite plugin takes every .tsx under pages/ for a page, so a test kept beside one is built into the production bundle; a test now fails when one is put there.
  • Every kit test is written in Pest. Nine files from the original scaffold (sign-in, email verification, password reset and confirmation, two-factor challenge, registration, profile and security settings) were still PHPUnit classes in a Pest suite; they are now Pest functions. The scaffold's ExampleTest that asserted true is gone; the one that checked a guest is sent from the home page to sign in is HomeTest.
  • .env.example offers every knob the kit adds. Eighteen settings the kit reads — the display timezone, PostgreSQL TLS mode and connection zone, the export and import row caps, the CPU and advisory thresholds of System Health, the demo accounts shut outside a demo, the sign-in-as limits, the Postmark and Resend keys — had no entry, so the only way to find them was reading config/. A test now compares every key the kit adds to config/ (beyond what the framework and each package publish) with the template.

Generator

  • One policy decides, and a module's HTTP layer is split by concern. A generated controller held six concerns — the resource, export, import, bulk actions, the trash, file downloads — in twenty public methods, and decided who may do what twice: ten can:<module>.<ability> rules in its middleware() beside the policy, which knew only update and delete; the pages guessed again from auth.permissions. Each module now has {Model}Controller with its resource actions, and every other thing its screens do is a controller of its own that answers with resource actions only — the record the form opens with is {Model}FormController@show, the CSV and Excel downloads {Model}ExportController@index and {Model}ExcelExportController@index, the import's dry run {Model}ImportPreviewController@store, a row back from the trash {Model}RestoreController@update, a bulk status change {Model}BulkStatusController@update, a workflow step {Model}TransitionController@update, a picker's search {Model}LookupController@index, a panel's delete {Model}{Child}Controller@destroy, and so on — the shape Laravel's own starter kits take and the one Pest's laravel architecture preset holds every controller to. The form's lookup lists are App\Queries\{Model}FormOptions::get() (a parent's page reads its child's), and the rules each import row is held to are Import{Model}Request::rowRules(). Every action is authorized with Laravel 13's #[Authorize] through the module's policy — viewAny, view, create, update, delete, restore, forceDelete, the selection abilities (updateAny, deleteAny, restoreAny, forceDeleteAny), export, import, approve, updateRestricted — and the policy is the only place a permission is named. The pages receive an abilities prop from the same policy, so a button shows exactly when its action is allowed; the export menu no longer shows to someone who may not export. The selection a bulk action works on is read off its request (selection(), trashedSelection(), target()), the list's filters off the query class (Filtered<Models>::fromRequest(), forRequest()), and the trash's routes bind the deleted record (->withTrashed()) so its policy is asked about it. Route names and URLs are unchanged; a module wired before is moved onto its new controllers when it is generated again — its route lines are found by their name and pointed at the controller that serves them now. A row deleted from a parent's panel is now deleted by its own module — its policy and its Delete action — where the parent's controller deleted it and wrote the audit entry itself.

  • A module's tests speak Pest, and check what a write ends in. Each route of the module and the permission it answers to is one row of a dataset — a user holding every other permission of the module is refused each — and each of the create form's rules is one row of another: blank where required, an array where text belongs, a character past the column, an address that is not one, a case the enum lacks, a negative amount, a key into nothing, a value another record holds; an optional field left empty is accepted, and a bulk selection that is not one is refused. A write's toast and redirect are asserted, not only its status; the index's props and the record page's fields are checked; a bulk delete of "every row the filters match" is shown to take only those, and its audit entry to name them; the trash's bulk restore and permanent delete are tested. Each file opens with pest()->group('<module>') (./scripts/test.sh --group=employee runs one module) and mutates(...) naming the module's controllers, actions, requests and policy, so pest --mutate measures the tests against them; each closes with arch() rules of its own. On the example Employee module the mutation score of those classes went from 24 % to 51 %; the tests from 82 to 143.

  • A module's web controllers live in a folder of their own. Split by concern, a module has a dozen or more, and they sat flat in app/Http/Controllers/ beside the application's own, while the same module's requests and actions were already one folder each. They are in app/Http/Controllers/<Model>/ now (Controllers/<Group>/<Model>/ with --namespace), as Laravel's own starter kit groups its Settings/ controllers; the class names stay whole (EmployeeBulkController), so no two modules share one, and the API controllers stay in Api/. Route names and URLs are unchanged. Regenerating with --force moves a module: its route file imports the new classes and the flat files the generator wrote are removed; a flat file it did not write is left where it is and named. Code of your own that names a module controller by class (App\Http\Controllers\EmployeeController) or imports its Wayfinder actions (@/actions/App/Http/Controllers/EmployeeController) takes the folder into the name.

  • A link to another module asks for the permission that module's policy checks. A page that links to a related module, or lists its rows in a panel, read that module's permission off a can:<permission>.view on its controller. Since the policies decide, no controller carries one, so the link fell back to the module's route name: for a module made with --permission, it was hidden from every role but super-admin. The permission is read from the module's policy now — a module from before the policies still from its controller — and the generator server is told it the same way.

  • A missing record is not told apart from a forbidden one, again. A caller without a module's permission got 403 for an id that exists and 404 for one that does not — enough to map which ids exist without reading one. App\Support\Auth\RouteGate closed that for can: middleware and skipped the policy abilities #[Authorize] puts on a route (view, update, … on the bound record). It asks the policy now whether the caller may do that to any record (viewAny, updateAny, …) and answers 403 when they may not; a caller who may still gets an honest 404.

  • A regeneration no longer reports moving a read route it left where it was. Every run said (form-data route) · moved to the read group and wrote the route file again: the group was looked for by its opening line directly above its marker, which stops being true once one route is in it.

  • Regenerating without --force leaves a module's policy, API description and API controllers alone. The client sent the generator server some of a module's files and not others, and wrote back whatever the server returned: a policy you had edited was written over, and a file the module no longer has stayed behind. Every file the generator can write for the module is sent now. The generator server has to be updated first: an older one refuses a policy it is sent.

  • A module's list page is composed from shared parts, and its filters have a file of their own. index.tsx held the whole screen in one component — the URL state and every visit that changes it, the loading and scroll listeners, the filter controls, the chips, the table, the bulk bar — 1,654 lines for the Employee example, most of them the same in every module. The parts that are the same are now shared: useListQuery (the list's URL state: navigate, runSearch, toggleSort, resetFilters), useNavigating, useScrollMarker and useBulkActions in resources/js/hooks/, and DataTable, RowIdentity, TableEmptyState, BulkActionBar, BulkSetMenu, StatusTabs and the overflow menu's OverflowItem, OverflowExportMenu, OverflowColumnsMenu and OverflowViewsMenu in resources/js/components/table/, each with its tests. What is the module's own — its filter controls and chips, with the option lists they read — is generated into resources/js/pages/<module>/filters.tsx as <Model>FilterPanel and <Model>FilterChips. The Employee page is 836 lines and Department's 705; the markup, the routes and the behaviour are unchanged, and the browser suite passes as it did. Three things were wrong on the way and are right now: a loading row hid its columns at the window's breakpoints while the row it stands in for used the card's, so the table changed shape as it loaded; an enum's filter chip showed the stored value (on_leave) beside a select reading "On Leave"; and the free-text filter asked for its values at a URL written into the page instead of through the module's route helper. A module generated before keeps working as it is; generate it again to move it onto the shared parts.

  • A module's form and record page are composed from shared parts too. After the list page (above), form-modal.tsx and show.tsx were the two files still copied whole into every module: the dialog, its fetch and placeholder, the "discard your changes?" guard, the footer, the details list, the audit trail and the delete dialog — 815 and 615 lines for the Invoice example. They are resources/js/components/crud/: CrudFormDialog, useFormGuard, CrudForm, FormField, OptionSelect, LineItemsEditor, LineItemsTable, RecordPage, RecordHeader, DetailList/DetailRow, RecordMeta, InfoCard and ActivityTimeline, each with tests; a module's files arrange them (the Invoice form is 339 lines, its page 246). A form's record is read through the form-data route helper rather than a URL written into the page, and a field's label now points at its control, a select included.

  • Editing a document opens on its lines. A master-detail module's form-data loaded the record's lines and then left them out of what it sent — the payload was the header's column set — so the edit form opened on one blank line: saving was refused for that line, or, once it was filled in, replaced every line the document had. The lines are in the payload now (the columns a person edits, and the label behind a searchable key), and a generated module test opens the form and counts them. Regenerate master-detail modules with --force.

  • A document's lines say which of them the server refused. The server names a refused line value items.<n>.<column>; the form showed only an error about the lines as a whole, so a wrong price on the third line was a refused save with nothing marked. Each message is now shown under its cell and marks the control (aria-invalid, aria-describedby), and lines are keyed by an id of their own, so removing one does not hand its input to the next.

  • A document's amounts are written one way, and previewed on the digits. On a module whose lines total qty × price, the discount, tax, subtotal and grand total are money and the tax rate a percentage, as if each column had been hinted mask:currency or mask:percent — the name alone made subtotal money and discount a bare number, so one invoice showed four amounts three ways. The lines and totals on the record page follow the same columns instead of an Indonesian format written into the page, plain decimals are shown with the places the column keeps (formatDecimal, new), and formatMoney no longer rounds through a float. The form previews its totals with lib/decimal (new), the client's half of App\Support\Money\Decimal, in the order the server computes them, so the preview and the stored invoice agree to the cent.

  • A master-detail record's API returns its lines, and its document asks for them. The API took items on create and update — required, at least one — but never gave them back, and the OpenAPI document did not name them: a client built from it was refused with 422 every time, and no endpoint showed a document's lines. Every single-record response (show, create, update) now carries items in the shape they are written in, with the amount the server worked out; the document describes them on the way in (required, minItems, each line's rules) and out. The lines are part of the record's version, so a read carrying them still answers 304, and a write from a copy whose lines another editor replaced is refused with 412.

  • A module's first page sorts its imports as every later one does. Until wayfinder had written a new module's route helpers, eslint could not resolve @/routes/<module> and sorted it among the external packages, so the first generation of a page and the second differed by two lines. eslint.config.js now treats every @/ import as the project's own (import/internal-regex).

  • Through the generator server, the names you are told are the ones the kit wired. After a generate the client named the permissions to grant from the route, ignoring --permission, and warned that a parent page "does not list" the module whenever the module had a panel key — it read the server's stand-in of the parent, which lists nothing. The kit now hands back the permission base and the panel parents, and the client checks the parents against your own models. A page that links to another module checks that module's own permission there too, as it does when generating locally.

  • A master-detail module writes through its Actions, and adds its money exactly. --detail modules kept their own store and update bodies in the web and API controllers — the transaction, the lines, the totals and the audit entry — and computed every amount as a float: (float) $qty * (float) $price, summed, then round(…, 2). They now write through Store<Model> and Update<Model> like every other module, so they gain what those carry: the version compared under a row lock, stamps, file handling, the importer. Amounts are worked out with App\Support\Money\Decimal (bcmath, on decimal strings): each line rounded to its price's places, then summed; the tax at a rate and the total rounded to the header column's; half away from zero. An update without items — a cell edit, a partial API write — keeps the stored lines and works the totals out from them, with the stored discount and rate where the request leaves them out; the module's tests now prove it. The line model written for a --detail module no longer names a policy no file declares — it stopped the module compiling. The conformance gate now generates a master-detail module, compiles it and runs its tests, and refuses a generated controller that holds a transaction, an audit entry or inline validation.

  • A selection's writes are Actions, as one record's are. Bulk delete, set status, reassign, restore and permanent delete wrote, logged and dropped the cached stats inside the controller — the one place a module's writes were not in app/Actions/<Model>/. Each is now an Action (BulkDelete<Models>, BulkUpdate<Model>Status, BulkAssign<Models>, BulkRestore<Models>, BulkForceDelete<Models>) that takes the query the controller built — the selection, live or in the trash, narrowed to scopeWritable() — and an App\Support\Audit\BulkTarget describing it, and returns how many rows it changed. The controller keeps authorization, the toast and the redirect; the audit entries and their wording are unchanged. Like the other Actions they carry a fingerprint, so --force replaces one only while you have not edited it.

  • A bulk action on a uuid-keyed module names the rows it touched. The audit entry normalised ids as integers, so every uuid was recorded as 0. BulkTarget keeps a uuid as itself.

  • Generated docblocks say "an employee", not "a employee" — in the delete, force-delete and transition actions, the form modal and the self-service and public API resources.

  • An API controller answers requests; its OpenAPI description is a class beside it. A module's admin, self-service and public API controllers each carried their part of the OpenAPI documents as one array literal in openApi() — 450 of the example EmployeeApiController's 620 lines were schema, so the endpoints were hard to find in their own controller. The description is now app/OpenApi/<Model>ApiSpec.php, written by make:crud with admin(), selfService() (--owner) and publicApi() (--public); each controller's openApi() returns its method, so the documents are built exactly as before. A module regenerated with --api gains the file; crud:remove takes it out with the module.

  • The trash is its permissions, and one record is checked as a selection is. A module's <module>.restore and <module>.force-delete were seeded and listed in the role matrix but decided nothing: the trash was the super-admin role's, hard-coded, so granting them did nothing. They are now the rule — either opens the Deleted view, each allows its own action, on the screen and the API — and the seeder still gives them to super-admin alone, so nothing changes until a role is granted them. And a write to one record ignored the model's scopeWritable(), which every bulk action is narrowed by: each module now has a thin policy (app/Policies/<Model>Policy.php, #[UsePolicy] on the model) asked by can:update,<record> / can:delete,<record> on its single-record routes. Regenerate with --force.

  • Models are declared the Laravel 13 way. A generated model restated its table and listed $fillable/$hidden/$timestamps as properties, where the kit's own User — and Laravel 13's skeleton — use attributes; a view model got a fillable list though nothing writes it; and the public ulid was mass-assignable. Models now carry #[Fillable([...])], #[Hidden([...])], #[WithoutTimestamps] and #[Table('...')] only when the name is not the one the class implies; a view has no fillable list, and ulid is filled by HasUlids alone. make:crud reads both shapes when it adds a column to an existing model. Regenerate with --force; the crud:custom block is carried over.

  • Generated comments say what is true, and nothing points at notes you never got. Shipped code and comments named the kit's internal tracker ids (TL91, "kit finding TL57"); a generated docblock read "Updates a employee"; writable() spoke of a policy there was none of; a workflow's bulk move promised stamps a module without stamps does not have; a self-service request inherited "Authorized by can:" from a controller with none; the screen's store() kept a variable it never used; and the README told you to run storage:link for files that are private. All corrected; the release build and the conformance gate now refuse a tracker id in anything that ships or is generated.

  • Generated tests check what their names say. "Creates a record and logs the activity" counted rows; it now checks there were no errors, that the text sent is the text stored, and that the created entry was filed. The API tests answer a missing record (404 not_found) and a body that fails its rules (422 validation_failed with the field named).

  • A table with no free text still gets an update test. The generated update test renamed a text column; a table without one (counts, flags, keys) had it skipped, and its Update action was exercised by nothing. It now moves a number the form writes between two values its rules accept (between:1,10 → 1, then 2), or turns a flag on.

  • Smaller rough edges, smoothed. An upload written inside a save that then failed stayed on disk with nothing pointing at it; it is now taken back when the transaction rolls back (StoredFiles::store() registers DB::afterRollBack()), for every module, no regenerate needed. A module's counts were one COUNT a state; they are one grouped query. A password field checked min:8 whatever the installation's policy said; it checks Password::defaults(). A typed slug that normalises to nothing (!!!) was saved empty; it falls back to the source column. Regenerate with --force.

  • Uploads are bounded the way OWASP asks. A gallery took any number of files a save, an image any pixel size, and resizing decoded whatever came: a 5 MB PNG of 20000×20000 asked for 1.6 GB and killed the queue worker on every retry. Images now carry dimensions:max_width=8000,max_height=8000, a gallery takes at most 20 files a save, and ImageVariants reads the size from the header and builds no size past 40 megapixels (the original is still served). Uploads go to filesystems.uploads (UPLOADS_DISK, default local) — StoredFiles::DISK is replaced by StoredFiles::disk(); code that named the constant names the method. The OpenAPI documents state both limits. Regenerate with --force.

  • Factories make their rows the way Laravel's own do. A required link picked a random existing parent (inRandomOrder() — a query per row, and a test that depended on what the last one left behind), an optional link did the same, a password was hashed per row, an enum was written as its string value and a length cap cut multibyte text mid-character. Now a required link is Parent::factory() (made only when the caller passes no parent; reuse existing ones when seeding with ->recycle($rows)), an optional link starts null, one Hash::make('password') serves every row as in Laravel's UserFactory, an enum is its case, and caps use mb_substr. A parent with no factory is still looked up and named when missing. Regenerate with --force.

  • Telescope no longer records the generator. In development Telescope recorded every query of every make:crud run, and a day of regenerating modules filled a disk: telescope_entries reached 34 GB inside the 48 hours the nightly prune keeps. make:crud, crud:remove, kit:remove-examples, the API document exports, images:variants and demo:reset are now in telescope.ignore_commands.

  • A page of photos is not refused halfway. Every route a module adds beside its resource sat under one throttle:30,1, so an index of fifty thumbnails — one request each — was answered 429 from the 31st, and a form's options and a row's form data counted against the same budget as an export. Reads one screen makes many of (file, form data, filter and picker options) now sit in their own group under the crud-reads limiter (600 a minute); exports, imports, mass edits and the trash under crud-bulk (30). Both are per user and set in config/table.php (MODULE_READS_PER_MINUTE, MODULE_BULK_PER_MINUTE). Regenerating moves an existing module's reads into the new group; a project without the two limiters keeps numeric throttles.

  • customRules() replaces any generated rule, create-only and update-only ones included. The Store and Update requests added their own rules after the base had laid customRules() over the shared ones, so a key there could not replace a rule only one mode has — though the docblock said it could. Those rules now come from modeRules(), which the base lays under customRules(). Regenerate with --force; the crud:custom block is carried over.

  • An inline-editable column that may be empty compiles. With --inline-edit, a nullable column's cell (item.x ? (…) : (<Empty />)) was handed to the editor inside a fragment, where it printed as text and lost its narrowing, so tsc refused the module. The cell is now passed as the expression it is. Inline editing stays opt-in. Regenerate with --force.

  • A bulk delete takes the uploads with the rows. A bulk delete was one query, and a query fires no model events, so the observer that removes a row's files never ran: the rows went, their photos stayed on disk. A module with file fields now deletes the selection row by row through its Delete action (or, from the trash, its ForceDelete action) inside one transaction — a row other rows still refer to refuses the whole selection, as the single statement did, and each row files its own audit entry. A module without files keeps the one statement. Each module with files tests it. Regenerate with --force.

  • The audit trail records the whole update. A password change, a multi-value enum and a gallery were left out of an update's entry, and a many-to-many change (retagging) was not recorded at all. Now the password is recorded as changed, blanked like a sensitive column ([redacted]); a list column is recorded as the list, and reads red, blue on the record's timeline; a many-to-many save records the links it attached and detached, read as + PHP, Go · − Java. A save that changed nothing files no entry. Each module tests the empty save and, with a many-to-many relation, the links. Regenerate with --force.

  • A related row in its trash cannot be picked by a request. Rule::exists() counted deleted rows, so a request could point a record at a parent the pickers never offer; and the bulk reassign took to=1abc to the database, which answered with a cast error — a 500. A foreign key, a picker's ids and the bulk target now use ->withoutTrashed() when the related table has a trash, and the bulk target is typed (integer, uuid, or string for a natural key) before it is looked up. Each module tests a trashed parent and a malformed target.

  • A number its column cannot hold is the field's error. An integer had no ceiling and a decimal no scale: quantity=3000000000 passed validation and came back from Postgres as an overflow — a 500 — and 12.505 in a numeric(12,2) column was stored as 12.51 without a word. An integer now stops at its column's range (int2, int4; MySQL UNSIGNED doubled), a numeric(p,s) takes at most s places (decimal:0,s) and p digits, and the OpenAPI document states both. Each module tests it on one such column.

  • A range with an open end is valid. Two columns paired with range-end: compared each other even when one was empty, and Laravel's date rules fail against nothing — so a start date with no end yet was refused. When the other end may be empty, the comparison now waits for it (Rule::when, read from the data being validated, so a form, an API call and an imported row are judged alike); a two-column CHECK on numbers is read the same way.

  • An import checks each row with the create form's own rules. The import validated with a second rule set the generator wrote beside the form's, and the two had drifted: a 200-character name passed the preview of a 120-character column, then failed in the database after earlier rows were written; a rating of 200 or a colour of "banana" went in. importRules() is now the Store request's rules for the columns a sheet carries (Arr::only), so the project's customRules() count too. A time field takes 09:30 and 09:30:00 alike — the form, the API and an export read back in. Each module tests that a row the form refuses is refused by the import. Regenerate with --force.

  • A workflow move is one locked, audited write. transition() read to straight off the request, updated the row and wrote the audit entry in the controller, with no transaction and no lock — two moves at once both passed against the same starting state — and the bulk move repeated the transition map inline. Now Transition{Model}Request validates the target, Transition{Model} locks the row, asks the enum's own canTransitionTo() from where the record stands now, applies the stamps and files one entry; a disallowed move is a 409 on JSON, a toast on screen. The bulk move goes through the same action row by row. The map lives on the enum (transitions()).

  • stamp-once:<column>=<value> — a milestone that stays. stamp:status=paid clears paid_at when the order moves on to shipped; stamp-once writes it the first time and keeps it. An English <x>_at / <x>_by pair is recognised beside <x>_pada / <x>_oleh, and make:crud warns when a stamp: sits on a state the workflow leaves. Stamps are documented in the README.

  • A cell edit is the form's write. Inline editing validated with a third rule set of its own (max:255 whatever the column) and wrote and audited in the controller, past the Update action — its stamps, its version lock. InlineUpdate{Model}Request extends the Update request, so a cell is checked by the form's rule for that column, and the change saves through the Update action. The status of a workflow, stamps, immutable and range-paired columns are no longer inline-editable. A partial write — a cell, an API call leaving fields out — no longer clears a show-if field whose controlling field it did not send.

  • The exports no longer hand out the trash. Only the list checked that the caller may see deleted rows; the CSV and Excel exports read the same filters without the check, so anyone holding <module>.export downloaded the deleted rows with ?filter[trashed]=only. The check now lives in the controller's filters(), which the list, both exports and every other reader of the filters go through. Each soft-deleting module's tests prove both exports refuse it. Regenerate with --force.

  • A typed-in tag needs the permission of the module it lands in. A "pick or type a new one" field created rows in the related table for anyone who could save the form — no <related>.create, no audit entry — and a name already in that table's trash came back as "has already been taken" under an unrelated field. Now <relation>_new is refused unless the caller holds the related module's create (read from that module's own controller, so --as/--route/--permission are honoured), the row is made by the related module's Store action (so it is audited and shaped like one added from its screen), and a name in the trash is refused on <relation>_new with "restore it there, or pick another name". The form shows that error under the picker. A master-detail parent links to a child module by the child's own permission the same way, where it guessed it from the route. Regenerate with --force.

  • A module over a database view. make:crud customers on a view answered "Table [customers] is not present", so a report over users and their orders became a hand-written page. A view is now a read-only module: list with search, filters, sort and export, the show page, the menu, .view/.export permissions, the GET API with --api and its OpenAPI, and tests — --read-only is implied and the flags that would write (--import, --inline-edit, --detail, --kanban) are refused. It needs an id column. A view declares no foreign keys, so the new hint fk:<table>[.<column>] on a view column makes the belongsTo (label, filter, link). Its tests make rows in the tables under the view through a hook the project writes, database/factories/Domain/<route>.php (a closure returning the view row's id), and skip with that file's name when it is missing. In server mode the client now sends views with the schema, and the server rebuilds them as views. (TL94)

  • A module without a form no longer fails PHPStan over its combobox. A combobox foreign key on a --read-only module emitted the <relation>PickerChain() the form's picker reads, unused without a form, and the closing check failed. It is emitted only beside a form now. (TL97)

  • Images in smaller sizes: image;variants. A list or a phone downloaded the full upload for every thumbnail. Hint an image column image;variants and each upload is also kept as thumb 320, medium 800 and large 1600 pixels on the longest edge — or the sizes variants:thumb=320,medium=800 names (1–5, 16–4096 px) — as WebP at quality 80, made with GD (no new package): never enlarged, the aspect ratio kept, turned upright from the EXIF orientation, metadata gone. They sit beside the original (products/abc.jpg → products/abc.thumb.webp); no column records them. The module's observer queues the new App\Jobs\MakeImageVariants after the write commits (3 tries, backed off, idempotent), and removes an image's sizes when it is replaced or its row deleted for good. The admin, API and public file routes take ?size= — the size once built (cached a day), the original until then (a minute), 422 for a size the column does not keep (App\Support\Files\ImageVariants); resources add <column>_variants URLs; the show page, form preview and relation panels draw the thumbnail; OpenAPI documents both. Galleries (image;multiple;variants) too. php artisan images:variants <module> [--column=] [--sync] builds them for rows that were already there. Modules without the hint are byte-identical.

  • A module whose file columns are all NOT NULL passes its own check. The observer filtered the paths it deletes with is_string(), which PHPStan level 8 calls always true for a string column, and make:crud stopped with "does not compile" (TL93).

  • Deleting a row with uploads, in a module without a trash, removes the uploads. Only a permanent delete from the trash did; a module without deleted_at left every file of a deleted row on disk. Its observer now discards them after the commit too (TL88).

  • What anyone may browse, through the API: make:crud --api --public. A catalog, blog posts, events — rows an app or a site shows to anyone, signed in or not — had only the admin API (a token and a permission) or the self-service one (the caller's own rows), so every storefront was hand-written. --public adds a read-only API beside the admin one, under /api/v1/public (API_PUBLIC_PREFIX, new in config/api.php): a list, a record and the record's files at the table's name — /categories for make:crud categories --as=category, whatever the admin module is called — named api.public.<table>.*, with no token and no permission, rate limited per address by the new public-api limiter (API_PUBLIC_PER_MINUTE, 120). Which rows anyone may see is the model's scopePubliclyVisible(), which the generator writes once into its crud:custom block — every row, until you narrow it — and never touches again; a row it leaves out is not listed and its URL is a 404. A record is found by --public-key=<column> (unique: a slug), else its ulid, else its id. A column hinted private (new hint) — and every password, sensitive and encrypted value, and the timestamps — stays out of Public<Model>Resource, the filters, the sort and the search (Filtered<Models>::publicSet()); there is no filter[trashed]. ?include embeds a relation only when the module at its other end is public too, through that module's own scope and resource, decided when the request runs (App\Support\Api\PublicApi). Files are served while their record is visible, raster images in place and everything else — SVG and PDF included — downloaded, cacheable for an hour (StoredFiles::publicResponse()). Documented in the OpenAPI document with no security requirement, and tested by a public api block in the module's test. Refused without --api, with --detail and with --owner. Modules without it are byte-identical.

  • A user's own records through the API: make:crud --api --owner=<column>. An address book, a wishlist, a device list — rows a user reads and writes from an app — had only the admin API, where staff see every row behind permissions, so the user-facing endpoints were written by hand, narrowing and all. --owner=user_id adds a self-service API beside the admin one, under /api/v1/me (API_SELF_PREFIX, read by the new config/api.php), at the table's name (/api/v1/me/cart-items), named api.self.<table>.*: the list holds only the caller's rows (same search, filters, sort, ?include and pagination), another user's record is a 404, the owner is set from the token on create and is left out of the request rules, the JSON and ?include, and records are addressed by ulid when the table has one. Writes go through the module's Actions with If-Match; token scopes and the api rate limit apply; there is no can:. The routes go in a new group at the crud:api-self marker of routes/api.php — added to the file if it predates it. The endpoints appear in the OpenAPI document and the module's test gains a self-service api block. Refused without --api, with --detail, on a table with file columns, and when the column is not a foreign key to users. The admin module, and every module without --owner, is byte-identical to before.

  • Modules for records the application writes: make:crud --except=create,edit,delete and --read-only. An order placed at checkout or a payment a webhook recorded is read, and at most worked through, in the admin — never typed in. Every module used to get New, Edit, Delete and everything behind them. A left-out ability now takes its routes (web and API), controller methods, requests, Actions, buttons, form modal, permissions and generated tests with it, and the generated test asserts the routes are not there. --except=create,delete keeps the edit form (an order's tracking number); --read-only leaves list, detail, filters and export. Regenerating a full module with --except --force removes the files it no longer has and the permissions it no longer checks; an Action or request you edited is kept and named. Combinations that cannot be honoured (--import without create, a board without edit, transitions without edit, --detail with --except) are refused. RowActions takes its handlers as optional props; ModulePermissions::names() takes without:. Full modules are byte-identical to before.

  • The detail page has slots the project owns: make:crud --show-extra. It writes resources/js/pages/<module>/show-extra.tsx once — ShowActions renders in the record header beside Edit and Delete, ShowPanels under the record card — and never overwrites it; from then on every regeneration keeps the page wired to it. Data the slots need beyond the columns comes from <Model>::showExtra() in the model's crud:custom block. For what a schema cannot describe: an order's status buttons and refund, a timeline, a summary. Before, that meant editing show.tsx, which the next --force overwrote.

  • A ulid column is filled on create. A char(26) column named ulid — a public id for an API — makes the model use HasUlids with uniqueIds(), stays off the form and the table, and is left out of the factory, which used to fill it with AB-12345. A model whose crud:custom block already uses HasUlids is left to it.

  • A regeneration takes out the generator's files the module no longer has, in any shape — the bulk "set status" request of a status that became no-form, the Store action of a module that lost create. An Action or request you edited, or a file you wrote under one of those names, is kept and named.

  • A status the application fills (no-form) gets no bulk "Set status". It was a way round whatever moves it — an order's state machine. no-bulk is no longer needed for that.

  • Wiring a sidebar icon leaves other lucide-react imports alone. A sidebar that also imports type { LucideIcon } had the new icon written into that line too, and did not parse.

  • A column a CHECK fills for one value of another is required for that value. (type = 'percent') = (percent_off IS NOT NULL) already shaped the demo data and the generated tests; the request let the field through empty and the database refused the row with a 500. A show-if field on that column and value is now required when shown; one always on the form gets required_if and prohibited_unless.

  • A CHECK added NOT VALID is read like any other. Postgres binds every row written after such a constraint but prints it with the two words appended, and the generator matched none of them: an enum, a bound or a required-when CHECK added that way — the usual way on a large table — was invisible to it. The same fix lets the generator server carry the two-column CHECKs above (required-when, ends_at >= starts_at, value pairs two columns may not hold together) to its rebuilt copy of your schema; generating through the server had dropped them, so its modules differed from a local generate. Needs the client bundled with this release.

  • A json/jsonb column is a document on every surface. The model casts it with the new App\Casts\JsonDocument (decoded on read; JSON text from the form kept, an array your code builds encoded), the request validates it with App\Rules\JsonValue (text from the form or an object/list from an API client, within a length), the API returns it as JSON rather than an escaped string, the export writes JSON text, and the form edits it indented. Before, the model held the raw string, so code writing an array needed a cast by hand — and Laravel's array cast then encoded the form's text a second time, while the export handed the array to the spreadsheet writer and failed with a 500. Regenerate a module with a json column to take this up. The table and export cell goes through JsonDocument::text(), so a NOT NULL json column no longer carries a null check PHPStan calls always false (the conformance fixture now has one).

  • Model docblocks name the date class the app returns. The kit runs Date::use(CarbonImmutable::class), so every date cast and now() is a CarbonImmutable; generated models (and User, OauthIdentity, ImpersonationGrant) documented Illuminate\Support\Carbon, which is not its parent, and PHPStan refused $order->paid_at = now() in your own code. Regenerate a module to take this up; a model you keep can swap the import by hand.

  • ModulePermissionsTest passes in a project with --except/--read-only modules or with permissions of its own on a module (order.refund). It compared every seeded permission with the full set and failed on both.

  • Merging labels tells a shared label from a dropped column. A key another module's file already labels used to be reported as "no column any more", which invited deleting a label still in use.

  • Money stored as integer cents is shown as money. An integer column named *_cents (price_cents, total_in_cents), or one hinted mask:cents, is labelled by its amount ("Price"), printed as $28.50 in the table, on the detail page and in related-record panels, and edited as an amount — the input converts, so the form, the REST API and the database keep the integer. CSV/Excel exports write 28.50 and imports read it back. Demo data seeds $1.00 to $500.00 instead of 0 to 1,000 cents. Before, price_cents printed 2800 for $28.00 under the heading "Price Cents". New: App\Support\Money\Cents, formatCents() in @/lib/format, and mask="cents" on MaskedInput.

  • Status badges are coloured by what the word means. active, paid, delivered are green; pending, refund_requested amber; shipped, processing blue; cancelled, failed, expired red; draft, archived grey; refunded violet — in English and Indonesian. Colours used to follow the order of the values, so enum:draft,active,archived drew the draft green and the live record grey. Words the list does not know keep their positional colours. Regenerate a module with --force to take this up.

  • Related-record panels show what the child's own table shows. A no-index column (a ulid) no longer takes a slot, an image column is a thumbnail instead of its storage path, a boolean reads Yes/No instead of an empty cell, an enum its label, and the panel holds six columns instead of five — a variant's stock and active flag were cut before.

  • make:crud --force keeps what you wrote by hand, as the README always said it did. It used to rewrite the abstract request and every Action: a rule or a line of logic written into them vanished on the next regeneration, reported as a written file.

    • The abstract request now has a // crud:custom block, carried like the model's. Rules the schema cannot state go in customRules() — a key there replaces the generated rule for that field — and rules() lays them over the generated ones.
    • Each generated Action carries a // crud:fingerprint line. --force replaces an Action only while it still matches it, keeps and names the ones you edited, and replaces those too only with --overwrite-actions.
    • A request from before the block is saved as .bak when --force would change it. Regenerate a module once with --force to take this up; an Action that is identical to what the generator writes now is fingerprinted silently.
  • crud:remove --dry-run (and kit:remove-examples --dry-run) now counts what the run does. It promised "100 paths, 7 files" for a run that removed 78 and edited 10: it counted the files inside a folder it was about to delete, and never saw an icon import or a route file become unused. The preview now plays the run out in memory.

  • A project that has removed the examples generates and tests cleanly. kit:remove-examples keeps routes/modules/.gitkeep, so a fresh clone still has the folder the next module and the suite write into.

  • display on an image, file, long-text or protected column is set aside with a warning, and the record is titled by a text column instead. Before, the index read a property its row type does not declare and the module did not compile.

  • A regex: hint keeps the pattern it was given. It was pasted between single quotes as it stood, so a pattern holding a quote (regex:/^[^']+$/) broke the request class. It is now written as an escaped PHP literal — unchanged byte for byte when it holds no quote and no doubled backslash. On the generator server, regex:/^[A-Z]{2}$/ — the form the schema recipes document — was refused both as a column comment and as --hint; it is accepted now as a ;-segment of its own that compiles, holds no quote, space or backtick and is at most 200 characters.

  • The API document lists each shared response under its own status code. Every operation documented Forbidden under 402 and Too Many Requests under 403: the shared responses were spread into the list, which renumbers integer keys. They keep 403 and 429 now, and each operation's responses are in status order.

  • Regenerating without --owner takes the self-service controller and resource out. They were taken for somebody's own work and kept, and the command named them.

  • A table with nothing to name a row by is named #id, not by a column the table leaves out. With no display hint the title fell back to the first short text column — which could be the ulid public id or a column hinted no-index, neither of which the index row carries. The delete dialog then read item.ulid and the module failed its own type check (a bag item: a ulid, two keys and a quantity). The title is now only ever a column the row has; display on a column kept off the table is set aside with a warning.

  • A combobox onto a soft-deleting table alone no longer fails the module's own check. A module whose only searchable lookup pointed at a soft-deleting table — users, once it is large enough for a combobox — got if ($config['soft']) over nothing but true, which PHPStan level 8 calls always true, and make:crud stopped with "does not compile". When every lookup soft-deletes the filter is now unconditional; mixed lookups keep their flag.

  • A soft-deleting table's slug no longer collides with a trashed row. The generated slug picker looks in the trash too, and the slug rule takes the column's own length instead of 255.

  • Generated tests write values the column's own rules accept. A validate:uppercase|alpha_dash column (a coupon code) is renamed to RENAMED-VALUE, not Renamed Value, which the form refused in eight generated tests.

  • On the generator server, make:crud no longer runs your RoleSeeder or the compile check. Neither means anything in the server's checkout, which does not have your project's classes; make:crud checks the written module in your project instead (php -l, PHPStan, tsc, eslint) and exits non-zero naming the errors. --no-verify skips it.

  • A show-if column that is NOT NULL with a default keeps its default. When its condition was off, the generated Store/Update wrote null into it and the factory did the same, so the database refused the row. Such a column is now set to its default; a nullable one is still cleared.

  • Generated tests stay inside the column. The search test's fixtures are cut to a short column's length, a number guessed from a column's name (tahun, jumlah) stays within its CHECK, and the conditional-field test never moves the condition to a system: value the form refuses.

  • A binary column stays out of payloads and the audit trail. A bytea column is read as a stream, which broke the activity diff and the JSON resource; it is now in the model's #[Hidden] and redacted from the audit entry.

  • A hidden enum column is documented as the text it is on the model, not as an enum class the generator never writes.

  • The created column's header follows the reader's language — read at render through a getter rather than once when the bundle loads.

  • A detail page's relation panels read like the child module. A panel shows an enum column by its label, not its stored value, and its heading is the child's --label rather than its table name. A child generated without a create form (--read-only, --except store) is listed as a plain section instead of a panel whose form does not exist.

  • The generator says what to do before a test goes red. A required key into a model without a factory is named at generate time, with the two ways out; a detail page that does not compile because a child module is missing or older says to generate that module first. The cascade picker is no longer warned about as if it were a combobox.

  • A second module over the same table leaves the first one's admin API alone. The admin API is named after the table, so a second module over it (make:crud employees --as=worker --api) edited the first's apiResource('employees', …) line, and removing the second took the line with it. The path stays the first module's; the second's API is generated but not wired, and make:crud says so.

  • --map works on a uuid-keyed table. MapPoint['id'] and pointHref take string | number.

Users, roles and permissions

  • The users module is built the way a generated module is. One UserController held the list, the form, export, import, four bulk actions, invitations, password and two-factor resets and impersonation — 1,089 lines, gated by can: middleware, validating inline and writing the audit trail itself. It is now UserPolicy, form requests in app/Http/Requests/User/, actions in app/Actions/User/ (each write in a transaction) and six controllers in app/Http/Controllers/User/ — the resource, export, import, bulk, account recovery and impersonation — every action #[Authorize]d through the policy. URLs and route names are unchanged. The CSV export, direct and queued, writes the columns UserColumns declares, and a queued export's signed download is ExportDownloadController.

  • An account above your rank is not yours to manage. Editing an account whose roles reach your level was refused; deleting it, suspending it, clearing its second factor, mailing it a reset link and the bulk actions were not. One rule now, RoleHierarchy::mayManageAccount(), asked by the policy for every action, and RoleHierarchy::manageable() narrowing every selection. The list shows each row only the actions its viewer would be allowed. assertMayManageAccount() is gone.

  • A refused save writes nothing. Saving an account in a way that took the last super-admin away was refused after the name, address and password had already been written. Every check now runs before the transaction writes, and an invitation leaves only once the account is committed.

  • A permission a policy checks counts as one the application depends on. The permissions screen refused to rename or delete a permission a route named with can:, and let through every one a policy checks behind #[Authorize] — every generated module's, since the policies decide. RoutePermissions reads both now; reading a route's authorization is shared with RouteGate in App\Support\Auth\RouteAuthorization.

  • A role grants only what its author holds, and a role above you is not yours. roles.create and roles.edit were a way round the hierarchy: a role could be created, or widened through the permission matrix — the caller's own role included — with permissions its author never held, and a role at or above the caller's level could be emptied or deleted. The grant rule RoleHierarchy::assertMayGrantPermissions() existed and was called nowhere. It is now asked for every permission a role gains, on the role form and the matrix; RolePolicy refuses changing or deleting a role at or above the caller's level or one they hold; the matrix asks about each changed role and refuses the save whole. The matrix receives which columns the viewer may change and which permissions they may grant, and locks the rest. Delegating role management to anyone but a super-admin is safe now; before, it handed out every permission.

  • Roles, permissions and the activity log are built the way a generated module is. RolePolicy, PermissionPolicy and ActivityPolicy; actions in app/Actions/Role/, app/Actions/Permission/ and app/Actions/ActivityLog/; controllers in app/Http/Controllers/Role/, Permission/ (the catalogue, a module's set, the matrix) and ActivityLog/ (the trail, its export). The trail's filters are FilteredActivities and its counts, facets and trend ActivityLogStats, beside the other query classes. The dashboard, the settings screens and the security board — screens without a model — are #[Authorize('<permission>')]; no controller in the kit implements HasMiddleware. URLs and route names are unchanged.

  • The permission matrix never overwrites a change it did not see. Adding, renaming or deleting a permission reloads the page's roles while the grid keeps its unsaved ticks; the next save then sent the roles' new versions with the old sets, and quietly reverted whatever someone else had saved in between. The grid now sends the versions it was built from, so such a save is refused as a conflict; it drops names the catalogue no longer has from pending edits; a grid without edits takes new roles whole; and Discard goes back to the server's current grid, so the save after a conflict can succeed.

  • A tick reads only what you can tick. A column or group holding everything the viewer may grant showed half-checked for good, because permissions they may not grant were counted. The role form now locks those permissions too — the server refused them already — while still letting the viewer take away what the role holds; Select all and a group's tick add only what may be granted.

  • Leaving the permission matrix with unsaved ticks asks first, as the role and user forms do. The catalogue dialogs and the save stay on the screen and pass. useUnsavedChanges() takes an optional staysOn(url) for screens like it.

  • Enter in a search box searches; it never submits a form. Pressing Enter in the role form's permission filter submitted the role. SearchInput now applies the term at once on Enter and stops the form's own submit.

Architecture

  • Rate limits are named for what they protect. Seventeen routes carried their limit as a number (throttle:6,1); they now name a limiter defined once beside the API ones — sso, sensitive, admin-actions, mail-test, backups, ui, and crud-bulk for the users bulk actions and the activity log export. The numbers are unchanged.
  • The admin API document is for whoever may use the API. /api/docs and its spec — every module, field and enum — answered any signed-in account; they now need settings.api, the permission that issues tokens. The public document is unchanged.
  • The kit's own models follow the generated ones. #[Fillable] instead of $fillable on the five that still used the property, and a factory for each model that had none (impersonation grants, starred menus, single sign-on identities, settings, saved views). Scopes keep the scopeX form throughout, deliberately: a #[Scope] method named search would replace Laravel Scout's static search() on a model that uses both.
  • Migrations are anonymous classes with a way back. The three activity log migrations were named classes, the health tables had no down(), and the second sessions migration's down() dropped the table the users migration creates — rolling it back signed everybody out. A test holds every migration to the shape make:migration writes.
  • Laravel's own conventions in the details. Queued jobs use Illuminate\Foundation\Queue\Queueable; queued mail and notifications retry three times with a backoff; notifications are translated and link with route(); six links in the interface use Wayfinder instead of a written path. The security board's queries live in App\Queries\SecurityBoardStats and its controller is SecurityBoardController — two classes were called SecurityController — and App\Support\Security\Policy, which is not a Laravel policy, is SecurityPolicySettings.
  • Dependencies the kit does not use are gone. laravel/chisel and rector/rector (whose configuration never shipped), and the database.sqlite a Postgres kit created on install. Dependabot watches Composer and npm as well as the workflows, and a high npm audit advisory now fails CI as composer audit does.
  • Every write the kit's own screens make goes through a FormRequest and an action. The generated modules already did; the kit's own screens validated inline ($request->validate() in eleven controllers) and wrote the audit log from the controller (22 calls in twelve). Settings → General, Mail, Security policy, Sign in as, API tokens, backups and failed jobs, the profile and password forms, the invitation, the role switch, single sign-on, saved views, starred menus and the language switch now each have a FormRequest under app/Http/Requests and an action under app/Actions/{Settings,User,Sso} that writes in one transaction with one audit entry, and an architecture test holds every controller to it. Single sign-on created the account and then its identity outside a transaction — a failure between the two left an account nobody could sign in to; they are now created together. A settings screen is recorded field by field, before and after, like a record (Setting::setMany()); the SMTP password as changed, never its value. Twenty-eight fields those screens validate had no label in lang/*/attributes, so an error named the raw key ("mail_host"); they have one now. The two super-admin-only screens check a named gate (manage-security-policy, manage-impersonation) through #[Authorize] instead of a role test inside the controller, and somebody else's saved view answers 404 instead of 403.
  • The kit passes Pest's php, security and laravel presets, with nothing ignored. tests/Unit/ArchPresetsTest.php runs all three, and a generated module passes them too. laravel holds every controller to Laravel's resource actions, so the kit's own controllers are split the way the generated ones are — route names and URLs unchanged: the users module (UserSearchController, UserBulkRoleController, UserBulkSuspendController, UserBulkActivateController, UserImportPreviewController, UserInvitationController, UserPasswordResetController, UserTwoFactorResetController; UserAccountController is gone), the settings (DataExportController, BrowserSessionController, MailTestController, FailedJobRetryController, FailedJobBulkRetryController, FailedJobBulkController, HealthRefreshController, and HealthReportController for /health), the API reference (ApiDocsSpecController, PublicApiDocsController, PublicApiDocsSpecController), the notifications (NotificationBulkReadController) and the starred menu (MenuFavoriteOrderController); a few took a resource name where one fits (OauthController's hand-off and return are create and store, a backup's download is BackupController@show). Code of your own that names one of these by class or imports its Wayfinder actions follows the new names. Besides the controllers: StaleRecord and LockedRecord are exceptions and live in App\Exceptions (they were in App\Support\Concurrency and App\Support\Workflow); the sign-in listeners answer handle() and are found by Laravel's event discovery instead of being registered by hand; TelescopeServiceProvider is listed in bootstrap/providers.php and does nothing where Telescope is not installed, so no class refers to a provider; the white-label logo's URL is Setting::fileUrl().
  • An API controller names its OpenAPI description instead of returning it. public static function openApi() on every generated API controller is now a class attribute, #[DescribedBy(EmployeeApiSpec::class, 'admin')] (App\Support\Api\OpenApi\DescribedBy), read by the documents without asking the controller; a record's files over the API have a controller of their own (Api\{Model}FileApiController@show, Api\Public{Model}FileApiController@show). Hashes that were md5 or sha1 — cache keys, record versions (ETags), the permission matrix's fingerprints, stored files' ETags, the sign-in failure keys — are xxh128; a generated action's fingerprint is sha256, and one an earlier generator wrote in sha1 is still recognised, so --force keeps telling an untouched action from an edited one. Temporary files are named once instead of through tempnam(). The demo seeders draw from random_int() and a seeded Random\Randomizer — Mt19937 draws exactly what the seeded mt_rand() drew, so the example data, and the manual's screenshots of it, did not move. The personal data export is a JSON response with a download header rather than printed output. ETags and other hashes change value once; nothing stores them across a release.
  • Invitations and export links go through the queue. UserInvitation and UserExportReady are ShouldQueue, as Pest's laravel preset expects of every mailable: a slow mail server no longer holds up the request that created the account. Run a queue worker (the Docker setup does).

Dependencies

  • Laravel 13.36. laravel/framework 13.34 → 13.36, with every update its constraints allow: Inertia 3.5, Fortify 1.41, Sanctum 4.3.3, Reverb 1.12, Socialite 5.31, Telescope 5.26, Wayfinder 0.1.21, Sentry 4.29, OpenSpout 5.12, Larastan 3.13, Pint 1.32. composer audit reports nothing. The stricter types they ship surfaced console code that cast an option or argument straight to a string — which an option holding an array would break — and fallbacks on schema keys that always exist; commands now read text through App\Console\Concerns\ReadsInput.
  • The two redirects the kit registers answer GET only. Laravel 13.36 added QUERY to the verbs Route::redirect() answers, and Wayfinder (0.1.21, its latest) cannot type that method, so the route helpers it writes for / and /settings failed tsc. Both are now Route::get() redirects to the same places; a redirect has no use for the other verbs.
  • spatie/laravel-permission 8. From 6.25 to 8.3: no schema change (the tables are the same), two optional config keys added (models.team, models.default_model, both null), and the event classes the config names gained their Event suffix. Code that listens for RoleAttached, PermissionAttached and the rest listens for RoleAttachedEvent, PermissionAttachedEvent, …; nothing in the kit does.
  • laravel-activitylog 5. From 4.12 to 5.1. What a write changed — old and attributes — has a column of its own, attribute_changes, and properties keeps only an entry's own data (the account impersonated, the size of a selection). Every action the generator writes, and the kit's own, records its diff with withChanges(); the record's timeline reads it from there, the activity log's detail shows it as a before/after table, and the export carries it as a Changes column. The migration upgrade_activity_log_to_v5 adds the column, moves the diffs already written (one statement on Postgres, a chunk at a time elsewhere — the history stays on every timeline), and drops batch_uuid, which nothing wrote; it moves them back on rollback. The config takes v5's keys: ACTIVITY_LOGGER_ENABLED is ACTIVITYLOG_ENABLED, delete_records_older_than_days is clean_after_days, subject_returns_soft_deleted_models is include_soft_deleted_subjects, and table_name/database_connection are gone (the table is activity_log). Code of your own that reads $activity->properties['old'] or ['attributes'] reads $activity->attribute_changes; getExtraProperty() is getProperty(); CauserResolver::setCauser() is Activity::defaultCauser() (facade Spatie\Activitylog\Facades\Activity); the package's classes moved namespace (see its UPGRADING.md).
  • Pest 5 on PHPUnit 13. pestphp/pest 4 → 5.3 with its Laravel plugin, phpunit/phpunit 12 → 13.4 and ParaTest 7.27. No test needed changing: the suite runs as it did (1353 passed).

Upgrading

  • make upgrade lists the files a patch removes as remove, not update.
  • The upgrade steps say make npm ARGS=ci. make npm ci also ran the Makefile's own ci target (the static gates) beside npm ci, which failed while node_modules was being replaced.
  • make upgrade works in a monorepo. With the kit in a subfolder of its repository (backend/ beside mobile/), git apply run from that folder skipped every path in the patch and the script reported "Upgraded" having changed nothing. Patches now apply from the repository's top with the kit's folder as their directory, and a patch that would change no file is refused instead of reported as done.

Interface

  • The sidebar's heading for modules without a section reads "Modules" instead of the examples' "Workforce".

Patch release, and the one to install: 1.19.0 was not published. The test for deleted rows through the REST API used the Employee example, so a project that had run kit:remove-examples saw it fail; it now sits with the example tests and leaves with them. Upgrade from 1.18.1 straight to this release; everything listed under 1.19.0 comes with it.

Minor release: no migration and no new environment variable, so make upgrade and make npm ci are all an install needs. Most of it is the generator. Modules generated from now on get the changes below; regenerate an existing module with make:crud … --force to take them up.

Generator

  • make:crud checks that the module it wrote compiles. It ends with php -l, PHPStan, tsc and ESLint over the module's own files and exits non-zero, naming the errors, when one fails — instead of leaving the broken page for whoever opens it next. --no-verify skips the check.

  • Regenerating keeps a model's hand-written block working. The imports the crud:custom block uses are carried with it; before, the second --force dropped them and the model failed at runtime on a class it no longer imported.

  • A foreign key is never a row's title. A table with no text column of its own chose its first foreign key, and the pages read a field the table never sends, so the module did not compile. Such a row is now named #id.

  • The ⌘K search entry follows the module. Regenerating rewrites its label and icon, and removes it when the module has nothing left to search; a stale entry answered 500 to everyone.

  • Factories import the model a hidden foreign key points at (a tenant column filled by the database), and keep it across --force.

  • panel is a hint the generator knows. Generating a child whose foreign key carries it says that the parent must be generated again to show the panel, and generating the parent with --relations names the panels still waiting for their child module.

  • A validation rule is written once (a uuid foreign key listed uuid twice).

  • Coded enum values can carry labels: enum:L=Laki-laki,P=Perempuan. The stored value stays the code; badges, tabs, filters, radios, the form and the record page show the label, and the generated PHP enum gains label(). Exports keep the code, so an export still imports back.

  • show-if takes several values or a negation: show-if:status=a,b,c shows a field for any of them, show-if:status!=a for anything else once a value is chosen. The request, the save and the form follow the same list. A foreign key works as the control too.

  • Form sections: section:Title on a column starts a titled part of the form at that field, running to the next one that names a section.

  • A child panel on a record's page is titled after the child module (through its dictionary entry when there is one), not its relation name run through English plurals.

  • A nullable foreign key made required with validate:required is seeded like a NOT NULL one in the factory and the generated test payload.

  • no-bulk on the status enum keeps bulk set-status out of the floating bar, for a column that cannot change alone (a Board still moves cards).

  • A key into a one-table hierarchy picks by path. cascade on a foreign key to a table that points at itself (provinsi → desa, dusun → RW → RT) gives one picker over the level the key points at, each row named by its path ("RT 003 · RW 001 · Krajan"), and validation that holds to that level. cascade:tingkat=kecamatan names the level column and the level; left out, the column is guessed (tingkat, level, jenis…) and the level is the deepest. The rows come from the new App\Support\Lookup\TreeOptions.

  • The Tree view compiles for a module keyed by uuid.

  • Encrypted columns you can still find. encrypted on a text column stores it enciphered (App\Support\Privacy\FieldEncryption, Laravel's encrypter under APP_KEY by default; bind your own FieldEncrypter for other keys), and a <column>_hash column beside it becomes its blind index: filled by the model, hidden everywhere, and matched by the search box against the whole value. A full NIK finds its owner; a fragment of one finds nothing. encrypted implies sensitive.

  • Periods (daterange) are a type of their own: two date pickers with an open end, "15/01/2026 – present" in the table, the record page and child panels, a factory value and a test value Postgres takes.

  • The factory keeps to two-column CHECKs of the shapes (a = 'x') = (b IS NOT NULL) and NOT (a = 'x' AND b = 'y'), and to show-if: a conditional column is drawn only when its control allows it, a forbidden pair is never drawn, and the bulk-status test seeds rows the database will let it move.

  • Project rules for a form: create resources/js/pages/<module>/form-hooks.ts exporting formHooks: FormHooks (@/lib/form-hooks) and regenerate; its derive(data, previous) fills fields from others (a NIK filling birth date and sex). Without the file nothing changes.

  • A key into a one-table hierarchy is named by its path in the table, the record page and the export too, and an import takes the path back.

  • Inline add works for a child generated with --namespace. A panel validates new rows through the child's own StoreRequest wherever its module grouped it; it named a class that did not exist, and the panel's one write endpoint answered 500.

  • A child panel shows what the child's own pages show. Columns the child keeps hidden, sensitive or encrypted stay out of the parent's panel (a hidden tenant column appeared there as a raw UUID), and a column's label: heads it there too.

  • A panel's inline add form uses the form's date pickers (dd/mm/yyyy) and translated buttons.

  • Decimals finer than three places (a coordinate) show every place; the locale formatter cut -6.031311 to -6.031.

  • Sign-off and locked states. approve:ditetapkan on a status column with transitions: makes moving into that state a permission of its own, <module>.approve, so the one who fills a record in and the one who adopts it can be different roles. locked:ditetapkan keeps a record in that state from being edited or deleted, by the form, the API, an inline edit or a bulk action; only its declared transitions still move it. The pages hide what the server would refuse.

  • A module generated for a table whose model was written earlier as another module's foreign-key target takes that model over without --force; it kept a model with no relations, and the module failed its own check.

  • A year column's factory and test values keep to its CHECK range (an RKP year held to 2015–2100 got 1990).

  • Generated tests keep to show-if: a key required only for some values of another field is created in the payload, the payload avoids a value that would need a row of a hierarchy it cannot make, and a search fixture written into a conditional column switches its control on.

  • A panel's inline add form is not offered when the child has a field required only for some values of another that the inline form cannot show; the panel links to the full form instead.

  • range-end on a column that is not a date or a time is ignored with a warning; two numbers are kept in order by a CHECK, which the generator already reads.

  • A panel adds rows through the child's own form. "Add" on a record's panel opens the child module's form over the page, with the key to the parent filled in and kept off the form — every control, label, mask, condition and section the child's index has. The panel's own compact form, which dropped lookups, lists and masks and showed enum codes, is gone, and with it the parent's add-a-child route (regenerating the parent removes the old route line). Deleting from the panel is unchanged. Any child with a panel key gets this panel, whatever its fields.

  • A locked record locks its panels. Rows belonging to a record in a locked: state cannot be added, changed or removed, from its page, the child's own pages, the API or a bulk action.

  • system:<values> on an enum keeps those values out of the form and refuses them from it, while tables, filters, badges and factories still know them: for a row only the application raises.

  • A stamp's <x>_oleh partner reads "<stamp label> oleh" and is folded away in the table, instead of a column titled from its relation ("Ditetapkan Oleh Ref").

  • A generated controller's formOptions() is public static, so a parent's page can hand the child's form its options.

  • A form whose conditional field is also the key a panel fixes compiles; the field and its condition were joined into one JSX expression that did not parse.

  • An enum label with a slash (kabkota=Kabupaten/kota) no longer fails the module's lint: labels are written without escaped slashes.

  • Generated tests mint a parent at the level a tree key accepts (cascade:tingkat=objek); they drew a random level and the request refused it in about three runs of four.

  • The table's timestamp column is headed from the dictionary ("Dibuat"), not "Created" in every language.

  • Long text on a record page keeps its line breaks, so a numbered list reads as a list.

  • The buttons of a panel's delete dialog have the height of every other dialog's.

  • A panel on a record's page no longer prints a child's foreign keys as raw ids (it shows the child's own columns; "View all" opens the full list), and its numbers follow their mask: money for currency or a money name, % for percent, a plain number otherwise. A volume and a percentage read as rupiah.

  • A generated test that needs a row at one level of a hierarchy uses one that exists before it makes one: a level that needs a parent (a desa under its kecamatan) was refused by the table's CHECK.

  • Bulk routes follow the controller. bulk-status and bulk-assign are written only when the controller has the method (a category enum, a no-bulk status or a combobox key leaves it without one), and a regeneration takes out a line an earlier one wrote. Such a line answered 500.

  • A NOT NULL list column (text[], or an enum hinted multiple) accepts an empty list: it is present, or may be left out when the column has a default, instead of required.

  • A validate:max: or validate:min: hint keeps the other side of the column's CHECK range: validate:max:50 over CHECK (n BETWEEN 1 AND 100) lost the floor of 1.

  • The generated bulk-reassign test makes its rows before the target and checks first that they point elsewhere; it passed without testing anything.

Changed

  • "Signed in as" now sits in the top bar. While you are signed in as another account, a chip next to the search box says whose account it is and holds the way back, and a thin amber line runs along the top of the screen. The strip fixed to the bottom of the screen is gone — it covered the account menu at the foot of the sidebar and the last row of every table. When IMPERSONATION_READ_ONLY is on, the chip also says Read-only.

Security

  • Deleted rows stay super-admin's through the REST API. ?filter[trashed]=only or with on /api/v1/<module> now answers 403 to anyone else, as the trash screen does; any token whose owner could view a module could list its deleted rows.

Patch release. No code, migration or environment change — only three build-time packages in package-lock.json, each lifted to the version that closes an advisory published after 1.18.0 shipped. make upgrade applies it; then run npm ci.

Security

  • shell-quote 1.9.0 → 1.12.0, through concurrently 9.2.4 → 9.2.5 (GHSA-pqg4-j6r4-53mv, critical: command injection in quote()). concurrently runs the processes behind composer dev.
  • source-map-js 1.2.1 → 1.2.2 (GHSA-68fv-2mgg-jv7q, high: an event-loop denial of service on crafted source maps). It is read by Vite while building.

Neither package ends up in the JavaScript your users download. They are fixed because npm audit reports them, and the security step of the shipped tests.yml lists every advisory rated high or above on each run.

Added

  • Sidebar groups fold. Click a group's caption to fold it; the choice is remembered per browser. The group holding the current page never folds, and searching opens every group.
  • Favourites. Hover a sidebar item and press its star. Starred items open from a launcher in the top bar and head the ⌘K palette before anything is typed. Up to 12 per person; the new menu_favorites table needs php artisan migrate.
  • "Sign in as…" in the user menu for anyone holding users.impersonate: search an account and become it. It lists only accounts you may become; the Users screen action is unchanged.
  • Demo accounts are refused on a real production deployment. A database brought over from development still holds its @demo.com logins, whose password is printed in the seeder; on APP_ENV=production with DEMO_MODE off they now stop working on the next request (web and API, whatever the way in), and the rows stay. The public demo is unaffected. Endings are set in DEMO_BLOCKED_ACCOUNTS (default @demo.com, none switches it off); add the key to your .env.prod.
  • Sign-in-as access can be time-boxed. Settings › Sign in as (super-admin only) grants one account the right to sign in as accounts below its own role, for 1 to 90 days, with a reason on record. Anyone but a super-admin now needs both the users.impersonate permission and a live grant; the session closes by itself when the grant is revoked or lapses, the account's owner is told, and the super-admins get a daily summary (impersonation:digest). IMPERSONATION_READ_ONLY=true makes every such session look-only. Needs php artisan migrate. ⚠️ If you had handed users.impersonate to a role other than super-admin, it stops working until you grant access here — that is the point.

Changed

  • A record's page is one card. The header, the details, the pivot relations (as a wide row) and Created / Updated / ID now share a card; the side rail is gone, and the status moves and the activity trail follow below in reading order. The title, the identifier and the status badge are no longer repeated in the details list. Fields with no value fold away behind "N empty fields hidden", an email or phone number is a link with a copy button (so is the identifier in the header), and the breadcrumb names the record. Generated modules pick this up on the next make:crud --force.
  • The account menu moved from the sidebar footer to the top bar, next to a theme toggle, the notification bell and the favourites launcher. The avatar takes the app's primary colour, so it follows the brand colour you set. The sidebar no longer has a footer.
  • Phones and tablets. Settings navigation is one scrolling row on a phone instead of an eleven-item list; the status tabs on Users stay on one line; a phone held sideways gets the off-canvas sidebar; between 768 and 1023px the search box shrinks to an icon so the page title stays visible. On touch screens the top-bar buttons are 40px and the row checkbox's tap area grows without changing how it looks. Table search fills the column on a phone, and the whole header cell is the tap target for sorting (generated modules and Users).
  • The invitation mail heading no longer carries an emoji, and shipped code comments are plain sentences.

Security

  • Names are neutralised before they reach a Markdown mail. The new sign-in-as notifications put a person's name into an e-mail; a name such as Eve [click](http://evil) would have arrived as a link. One helper (App\Support\Mail\MarkdownText) now does it for these mails and for the invitation.
  • Dependencies updated (Laravel 13.18 -> 13.34, league/commonmark, league/flysystem, phpseclib) to close five published advisories; the lockfile is what you install from. composer audit and npm audit report nothing.

Fixed

  • ⌘K search no longer fails on a module titled by an enum column. A hit's label is now spelled the way the table spells the value (on_leave → "On Leave"); before, the whole search answered 500 as soon as such a module matched.
  • The notification bell's screen-reader label follows the app's language — it was fixed in English.
  • Sign-in and password confirmation no longer mismatch between server and browser when server-side rendering is on: passkey support is decided after hydration, not during render.
  • Uploaded logos and favicons no longer 404 on platforms that build the image themselves (Coolify and similar). The public/storage link is now part of the production image instead of a step in prod-deploy.sh, so it also survives a container being recreated. Rebuild the image to pick it up.
  • Impersonation no longer carries one person's session state to the other. A fresh password confirmation and the "act as" role are cleared when impersonation starts and ends.
  • The Roles screen only offers what you may do. New, Edit and Delete follow roles.create, roles.edit and roles.delete instead of leading to a 403.
  • Switching role lands on the dashboard, not on the page it was made from — which the narrower role often cannot open. Its messages are translated and use the role's display name.
  • Sending a password reset twice in a row now says the first link is on its way, instead of reporting a failure.
  • The Permissions screen is read-only without the rights to change it. The matrix needs roles.edit; adding, renaming and deleting permissions need permissions.assign. Without them the checkboxes are disabled and the edit controls are not offered.
  • Rich text no longer breaks hydration when server-side rendering is on.
  • A wide table can no longer push the page past the window and slide the top bar over the sidebar: the content column may now shrink below its content.
  • Avatar initials skip punctuation and notes in brackets — "Jane Doe (demo)" is "JD", not "J(".
  • The "acting as a narrower role" note on the 403 page and the "Primary" marker in the role switcher are translated.
  • Roles are shown by their display name everywhere, not only on the Roles screen: the account menu, the 403 page, the Permissions matrix, and the Users table, filters, bulk menu and form. The key (super-admin) stays what filters and code use.
  • Activity log event names follow the app's language in the tabs, the row badges and the detail panel. An event a module writes itself keeps its tidied key. Entry descriptions are unchanged: they are stored text, like notification bodies.

A generator release, shaped by building real modules on 1.16 — schemas in Indonesian and English, master-detail forms, state machines, uploads, and tables with thousands of rows. One change matters before anything else: uploaded files are private now. Read Upgrading first; everything else is additive or a fix.

Upgrading from 1.16.1

  1. Apply the patch as usual (make upgrade …1.16.1-to-1.17.0.patch, see UPGRADING.md).
  2. Regenerate the modules you generated yourself (make:crud <table> … --force --wire). Most fixes below reach a module only through its generated files. Code you wrote into a model survives if it sits between // crud:custom and // crud:custom:end — a model from before those markers is saved as <Model>.php.bak when the regeneration would drop one of its methods, and the command names them.
  3. Uploads. New uploads go to the private local disk and are served through each module's file route. Files already on the public disk keep working — they are found and deleted there — but they stay reachable at /storage/… until you move them: move storage/app/public/<table>/ to storage/app/private/<table>/ (the stored paths do not change).
  4. Category enums. Status tabs, the header status pill, per-status counts and bulk "set status" now belong to an enum that is a status (see Changed). A category enum that relied on them keeps them with the tabs hint.
  5. PostgreSQL time zone. The database session now uses APP_TIMEZONE (DB_TIMEZONE overrides). now() in a trigger or a column DEFAULT agrees with the timestamps PHP writes; check any SQL you wrote that assumed UTC.

Security

  • Uploaded files are private and leave only through their record. file / image columns (single and ;multiple) were stored on the public disk and linked as /storage/<path>, so anyone with the URL could download a file past every permission and row scope. They are now stored through App\Support\Files\StoredFiles on the private local disk and linked to a new per-module route, GET /<route>/{id}/file/{column} (?path= for a gallery item; the REST API gets the same under api.v1.). The route binds the record — global scopes included — behind the module's view permission, and a column or path the record does not hold is a 404. Images and PDFs open in the browser; anything else downloads, so an uploaded SVG or HTML file never runs on your origin.
  • Bulk actions stay inside the rows the user may change. A bulk delete, status change, reassignment, restore or force-delete is a single query, so neither the policy nor the model's events see the rows. Every bulk target now passes through a generated writable(), which applies the model's scopeWritable() when it declares one. Declare it wherever users may read rows they may not change.
  • Bulk "set status" on a state machine goes through the machine. It ran a raw UPDATE — no transition rule, no stamps, no model events. It now walks the rows through the same rule as the workflow buttons and skips the rows the rule does not allow.
  • Module counts are cached per viewer scope. {Model}Stats kept one cache entry per module, so where rows are narrowed per user (a branch, a tenant, a unit) the first viewer's totals reached everyone for a minute. Register a resolver with App\Support\Table\StatsScope and every module's counts are keyed by it.
  • An app-filled foreign key is not importable. An FK hinted no-form;no-index (a tenant or owner key the app sets) could be set by name from a CSV import. It is now left out of the import, and no-index on any FK keeps it out of the table's row payload.
  • crud:remove no longer deletes hand-written route files. It pruned every file in routes/modules/ without a Route::resource( — including modules routed with Route::get(). Only an empty generator scaffold is pruned now.

Changed

  • A category enum is not a status. The status machinery now needs an enum that is one: hinted tabs (or the older status), carrying transitions:, or named status, state, stage, phase, tahap, fase or keadaan. Any other enum is a filter and a badge; its bulk "set status" rewrote the category of every selected row. Category badges use neutral hues instead of the green-to-red status order.
  • A table is never given a second module. Generating a table that already has a module under another name (created with --model / --as) is refused, and the message names the flags to rerun it with. A model name PHP reserves (classes → Class) is refused with a suggestion instead of producing a class that cannot load.
  • Labels for new columns are merged on regeneration by default. Missing labels are appended to lang/*/attributes/<module>.php; existing wording is never touched. --keep-labels opts out (--merge-labels is still accepted).
  • Regenerating without --wire keeps a wired module's routes in step. A route the new code calls — an fk-options lookup, the file route — is added to the module's route file, the route helpers are rebuilt and the pages linted again.
  • Page layouts are built at render time (Page.layout = () => ({ … })) in the generated pages and in the kit's own. Built at module load, the breadcrumbs were translated before the page's language was known, and a server-rendered page came out in the wrong language.
  • The model stub has a // crud:custom block for relations and helpers written by hand; it survives --force.
  • The PostgreSQL session uses APP_TIMEZONE (DB_TIMEZONE overrides).
  • A start/end pair of times is shown in the index by default; a lone time column is still secondary.

Added

  • Declared formats drive everything. validate:url / email / ip / uuid now decides the factory value, the generated test payload and the detail page, ahead of the guess made from the column name; a URL is a link on the detail page (http/https only).
  • Two-column CHECKs on numbers are read. b >= a, a <= b, b IS NULL OR b >= a and the strict forms give the constrained column a gte: / gt: / lte: / lt: rule, an ordered factory value and a test payload that satisfies it.
  • Hints: sort:asc|desc (a column as the index's default order), widget:Name (a field the project renders itself from resources/js/widgets/), no-bulk (an FK that never takes the bulk "assign" action).
  • Project hooks for generated tests: tests/Payloads/<route>.php merges into a module's test payload and database/factories/Domain/<route>.php into its factory, for rules the schema cannot state. The generator never touches either directory.
  • make:crud names what it cannot read or will not keep stable: words in a column comment that are not hints (a sentence after a ;, a typo), foreign keys that became a combobox only because the target table is large today (pin them with combobox or select), and a wiring marker that is missing.
  • An EXCLUDE constraint violation is a message, like a CHECK violation, instead of a 500.
  • lang/{en,id}/auth.php — a wrong password no longer shows the raw key auth.failed.

Fixed — generated modules

  • Editing a row on a table whose route has a dash no longer answers "already taken": the resource parameter is named, so Rule::unique()->ignore() and whereNumber() find it (web and API; --wire upgrades an existing route line).
  • A combobox lookup no longer offers soft-deleted rows.
  • A datetime field opens in the edit form with its value instead of NaN/NaN/NaN.
  • A display hint on an enum column no longer throws on every save, delete and restore.
  • A UNIQUE integer is validated in the request and drawn uniquely by the factory and the test payload; a unique float is drawn uniquely too.
  • Generated tests pick columns they can write (not a generated, no-form or too-short title), count relative to rows a migration seeded, use a column's DEFAULT and its bounds for integers, cut a detail line's values to the column, and count detail lines from the payload.
  • Factories: a machine column (ltree, tsvector, bytea) is never seeded; a boolean and a state machine start at their DEFAULT; a nullable hidden column is seeded null; an FK to a model without a factory points at a seeded row instead of calling a factory that does not exist; show-if fixtures match the column's kind, mint a real parent for an FK and expect [] for a list column.
  • Master-detail: the controller and types.ts parse; the line model no longer names an observer that does not exist; line enums are named after the line model; no-form line columns are neither validated nor drawn; a line FK past the combobox threshold searches instead of loading the whole table; line keys have labels, and items is shared vocabulary.
  • A one-to-one relation panel no longer throws a TypeError on the parent's detail page.
  • Workflow buttons show the status label, not its key.
  • Bulk "assign" goes to a foreign key the form can set.
  • Unused imports are no longer emitted: Label, FilterChip, Select, CascadeSelect, fkOptionsUrl, a relation panel's row type or show route; a radio-only enum form imports enumLabel.
  • --calendar on a NOT NULL column, replacing a file on a NOT NULL file column, and a PROTECTED_MODULES entry no longer fail PHPStan; --inline-edit modules type-check.
  • A stamp: column not named <x>_pada is no longer its own partner.
  • A polymorphic pair has attribute labels.
  • Safe merge writes a new column the way full generation does — its rules (validate:, column length), its label and its imports — and no longer emits an undeclared inputClass.
  • The index: view names are translated; the search placeholder names one column and keeps the full list in its tooltip; the row-action column stays visible at the right edge of a wide table.
  • HardcodedTextTest no longer reads an Indonesian schema's column names as prose.
  • A slow formatter is a warning, not an aborted make:crud.

Fixed — application and tooling

  • The ⌘K palette shows its navigation, action and preference groups in every language.
  • A navigation link carrying a default filter is highlighted as active.
  • The first npm install no longer rewrites package-lock.json.
  • A Docker Compose race during dev-init.sh no longer leaves the app without APP_KEY.
  • create-project refuses a name Docker already uses as a compose project.
  • Telescope no longer records db:seed.

Patch release. Nothing new; every entry came out of an independent clean-VM audit of the 1.16.0 bundle and was verified the same way: four fresh Ubuntu 24.04 VMs, Docker and native, each on PostgreSQL and MySQL/MariaDB, following only the shipped docs — 4/4 passed.

Fixed (installing from nothing — clean-VM audit, 2026-09-21)

The 1.16.0 bundle was installed from zero on four fresh Ubuntu 24.04 VMs by an independent audit (Docker and native, each on PostgreSQL and MySQL/MariaDB), following only the shipped docs. Every path reached a running application; the native path did so only after deviating from the docs, and the test suite did not run on MySQL. Each cause is fixed here.

  • composer install no longer refuses PHP 8.4 installs — and no longer claims 8.3. composer.lock pinned Symfony 8 and OpenSpout 5.7, which need PHP ≥ 8.4.1, while composer.json said ^8.3 and the native guide told Ubuntu users to apt install php8.3-cli: a documented path that could not complete. The requirement is now ^8.4 and config.platform.php is pinned to 8.4.1, so the lock can never again resolve above what the docs promise. The native guide gives the Ondřej/Sury and NodeSource commands for Ubuntu 22.04/24.04 and Debian 12/13, whose stock PHP (8.2/8.3) and Node (18) are too old.

  • npm run build no longer fails on the Node the docs used to install. The guide's apt install nodejs npm yields Node 18 on Ubuntu 24.04; Vite requires ≥ 20.19. package.json now declares engines so npm ci says so up front, and the guide installs Node 22.

  • make test works on a MySQL/MariaDB installation. scripts/test.sh was hardcoded to the postgres service and DB_CONNECTION=pgsql, so on a MySQL install it died with "service postgres is not running" while the README promised the same targets on either engine. It now follows DB_CONNECTION in .env, like make and dev-init.sh do, and creates the testing database on whichever engine is running.

  • php artisan test works on a native MariaDB/MySQL installation. phpunit.xml forced DB_CONNECTION=pgsql, which made the suite speak the PostgreSQL protocol to port 3306 (685 failures). The engine now follows .env; only the database name is forced. The native guide no longer claims the suite runs on in-memory SQLite — it never did — and says how to create the testing database.

  • First make init builds one image, not four. app, queue, reverb and scheduler each carried the same build: with no shared image:, so Compose built four identical images in parallel — four compilations of the PHP extensions, four composer install, four npm ci. On a 4-vCPU / 6 GB machine that was 20 minutes and two npm ci idle timeouts before the first successful run. Only app builds now; the other three use its image (${COMPOSE_PROJECT_NAME}-app:dev, pull_policy: never). Same for compose.prod.yml.

  • Native guide: PostgreSQL setup that works on a stock Debian/Ubuntu. createdb codebooster as your own user fails there ("role does not exist"); the guide now creates the database and sets the postgres password as the postgres user, gives the MariaDB equivalent, and lists pdo_mysql among the extensions for that engine.

  • One page count for the manual. README, the store and docs/manual/README.md quoted 36, 38 and 25 pages for the same PDF; it has 38. The README also says which MySQL the Docker overlay ships (8.4) versus the MariaDB the native path supports (10.11+/11).

The pre-release audit for a global audience, closed out. No new migrations; upgrading is make upgrade with the 1.15.1-to-1.16.0 patch, then make:crud … --force on the modules you generated (see Generated modules below).

Security

  • Invitation e-mails no longer render Markdown from user-supplied text. The inviter's name and the application name were interpolated raw into a Markdown mail, so a name written as Eve [click](http://evil) became a link in an e-mail the recipient trusts. Both are now neutralised before rendering.
  • Authenticated ZAP pass on this release: no new findings. Eight alerts, every one already known and decided (development-only CSP overrides, the CSRF cookie that must be readable by JavaScript, the audit trail's own IP column); the REST API scan with a bearer token reports nothing. This is a passive scan and is not a claim of a penetration test.

Changed

  • Eloquent runs strict outside production. A relation that was not eager-loaded, or an attribute a model does not allow to be mass-assigned, now throws in local and testing instead of silently costing a query or a value. Production is untouched. If your own code trips it, the exception names the model and the relation — that is an N+1 or a fillable gap you would otherwise have shipped.
  • shadcn/ui components refreshed to the current registry — the unified radix-ui package, data-slot attributes, and upstream fixes. calendar is the current upstream component with this kit's month-and-year dropdown caption kept; dialog keeps its motion, flow layout and DialogBody, and gains upstream's showCloseButton on DialogContent and DialogFooter, so code copied from the shadcn docs works as written.
  • Comments now read like Laravel's own. Across the application and every generated module, a docblock states the decision in a few sentences — not the history behind it, not measurements, no emoji. The example modules shed roughly half their comment lines and none of their behaviour. scripts/comment-density.py measures it.
  • Manual: the introduction is rewritten; the walkthrough names make:crud as the one-command path and builds the same result by hand so every file is explained.

Removed

  • FormActionBar, NavFooter and useErrorToast — nothing in the kit used them. If your own pages import one, copy the file from 1.15.1; nothing else references it.

Fixed

  • Users form on a phone: the role list's "Full access — bypasses all checks" pushed the super-admin name clean off the row; the meta now sits under the name at narrow widths.
  • Settings › Appearance on a phone: the Density control ran past the card edge.
  • A detail page's back link named the module in the singular ("Back to Employee") while pointing at the list.
  • ExampleDataSeeder can be run directly again ((new ExampleDataSeeder)->run()); it used to work only through db:seed, which unguarded it for you.
  • Bulk role assignment on the Users screen queried once per selected account.

Generated modules

Regenerate with make:crud <table> … --force to receive:

  • Four more API tests per module — an unknown filter, sort or include is refused with 400 rather than ignored; per_page outside the allowed set falls back to the default; a suspended account's token is refused; ?include= embeds a relation only when asked.
  • The comment style above, in every emitted file.
  • The plural back link on the detail page.

Fixed

  • A person held by the security policy now sees why on their very first visit. The reason used to travel as a one-shot session message, and the password-confirmation step that Fortify puts in front of the two-factor settings spent it — so the first thing a held person saw after signing in was the Security screen with no banner, and the explanation only appeared on their next click. The screen now reads the reason from the account itself. While impersonating, where the policy holds nobody, no banner is shown either.

First public release.

The version number carries the product's development history: the builds before this one were internal and were not sold. This is the first release a buyer receives, and the root of the upgrade-patch chain.

The application

  • Accounts — invitations by signed link, suspension, roles, an effective-permission preview that updates before you save, bulk actions, and CSV export and import. An import is checked row by row — name, email, roles, optional password — before anything is written, and a queued export emails a signed download link.
  • Access control — roles, a grouped permission matrix with per-role coverage meters, can: middleware on every controller action, and a super-admin that bypasses the gates. A module is invisible to a role until its permissions are granted deliberately; export and import are permissions of their own, separate from reading the screen.
  • Account security — two-factor authentication with an authenticator app and recovery codes, passkeys, browser sessions with sign-out-everywhere, and a password change that ends every other session on its next request.
  • Security policy — which roles must have a second factor, what a password must look like and how old it may get, and how long a session may idle — set once by a super-admin and enforced on every request. Someone who falls short is held at their Security screen with a banner that says why, not signed out. Nothing is required by default.
  • Single sign-on — Google and GitHub, linkable to an existing account. A provider appears only once its credentials are configured, so a fresh install shows no buttons and has nothing to switch off. No provider tokens are stored.
  • Security board — failed sign-ins and lockouts over 24 hours, 7 and 30 days: the addresses behind them, the accounts they target, detections graded by severity, and a posture panel that names the .env key or screen behind each finding.
  • Audit trail — every create, update and delete with the actor, the event and a field-level diff, plus a per-record timeline on every detail page. IP address and user agent are recorded for requests that have one; every export is recorded with who took it, what, and under which filters. Columns marked sensitive are redacted in the diff — the audit says the value changed, not what it was.
  • Concurrent edits — every write screen carries a fingerprint of the record as it was read, and a save made from a copy somebody else has since changed is refused with an explanation rather than applied over their work. Nothing is locked and no save waits on another.
  • Live tables — an index refreshes itself when someone else changes a row, over websockets, without stealing your selection, your open dialog or your place on the page. The broadcast carries no data; the browser re-asks the server, which applies the reader's permissions and filters as usual.
  • Saved views — a filter set anyone can name and come back to, per module, per person.
  • Trash — deletes are recoverable, in bulk, and permanent deletion is a separate permission held by super-admins.
  • Queue visibility — background work that failed, with its stack trace, retried or deleted from the UI — behind its own permission, because a stack trace carries whatever the failure did.
  • Support tooling — sign in as another user to reproduce what they see. Security settings are read-only while impersonating, and the audit trail names the real actor, not the borrowed account.
  • Privacy — a person's data exported as JSON on request, an account anonymised instead of hard-deleted so the audit trail keeps its shape, and activity records expired on a schedule. The export and the anonymisation share one definition of what is personal, so neither can drift from the other.
  • Application settings — app name, brand colour and logo, SMTP (encrypted at rest), database backups, and system health with the dependency-advisory check, all from the UI. A brand colour that would leave the primary button unreadable is refused.
  • REST API — Sanctum tokens with scopes and expiry, and an OpenAPI page you can call endpoints from.
  • Operations — every request is answered with an X-Request-Id that appears on each log line it writes, on any job it queues, on the Sentry event and on the error page as the reference a person quotes to support. LOG_CHANNEL=json writes one object per line for Loki, Datadog, ELK or CloudWatch; text stays the default.
  • Two languages — every string in the interface reads from one dictionary, English and Indonesian, switchable per reader with nothing rebuilt.
  • Locale, not guesswork — one currency per installation and one date shape everywhere (dd/mm/yyyy, 24-hour clock). Timestamps are shown in the reader's own time zone by default, or the installation's, by preference; the database stays in UTC.
  • Dashboard — head counts, distributions and a daily activity curve drawn at the resolution the data exists at, from cached aggregates that the observers invalidate.
  • Accessibility — axe-core runs over every screen in CI, signed out and signed in, in both themes, and a violation fails the build. This earns "axe-core clean in CI"; it is not a claim of WCAG 2.2 AA conformance.
  • Demo mode — one flag turns an install into a public demo: printed sign-in accounts, destructive actions refused, database rebuilt on a schedule. Off by default, and absent rather than disabled when it is off.

The example modules

Department, Skill and Employee — a lookup behind a foreign key, a pivot edited as a tags input, and a wide table using both. Complete modules with query classes, cached counts, transactional actions, a REST API and their own tests. They are the pattern to copy, not scaffolding to delete, and php artisan kit:remove-examples takes them out cleanly when you are done with them — the test suite stays green afterwards.

Every module carries the same shell: search, status tabs, a filter panel whose active filters stay visible as chips when it is closed, a column menu that remembers only your deviations from the schema's defaults, three densities, frozen identity columns, a footer paginator, bulk actions, trash, CSV and Excel export with spreadsheet formula injection neutralised, spreadsheet import with row-by-row validation, a detail page with a status flow and an activity rail, and a table that keeps itself current. Column types cover text, numbers with currency and percentage masks, dates and date ranges, enums as tabs, radios or selects, foreign keys as searchable pickers, pivots as tags, JSON, arrays, files, rich text, coordinates on a map and Postgres network types.

Databases and deployment

  • PostgreSQL 18 is the engine the kit is built on. MySQL 8.4 and MariaDB 11 run the product through the mysql driver, with four things that are absent there rather than slow: array columns, the inet and macaddr types, trigram search, and reusing the e-mail address of a soft-deleted account. The list is in docs/install-without-docker.md.
  • Docker — FrankenPHP with Caddy built in, PostgreSQL, Redis, Reverb, a queue worker, a scheduler and Mailpit, every image pinned to a patch version so two installs made months apart run the same stack. A supported path without Docker for PHP, Composer, Node and a database you run yourself.
  • make as the front door — make init, make up, make test, make doctor (a first-day check of the installation where each finding names its fix), and the rest of the day-to-day targets.
  • Production — compose.prod.yml with an explicit environment allow-list, compose.proxy.yml for a host behind a reverse proxy, TRUSTED_PROXIES so the audit trail records the client and not the load balancer, a fail-closed Content Security Policy with one knob each for map tiles and embedded documents, and /health for an uptime monitor.
  • Upgrades — from this release on, every release ships with a patch from the previous one, applied as a three-way merge that keeps your edits and names the few places you and the kit changed the same lines.

What has been checked

  • 703 Pest tests in the bundle (484 once the examples are removed), 286 Vitest tests, and 59 Playwright tests including the accessibility sweep; PHPStan at level 8; pint, eslint, prettier and tsc as gates on every push, with composer audit and npm audit beside them.
  • Before release, the bundle is installed from nothing in a clean virtual machine four ways — Docker and native, each on PostgreSQL and on MySQL/MariaDB — and the suite is run on each engine there.
  • SECURITY.md says how to report a vulnerability, which versions get fixes, and what has been checked stated the way it was measured. docs/security-controls.md maps every control to the file that implements it and the test that locks it, grouped the way ISO 27001, SOC 2 and OWASP ASVS group them — a map for your own assessment, not a conformance claim.

Notes

  • PHP 8.5, Laravel 13, React 19, Inertia 3, Tailwind 4, PostgreSQL 18, Redis 8, served by FrankenPHP.
  • A fresh install has no accounts by design; php artisan user:create makes the one you sign in with. Nobody can register themselves, and the demo logins are refused outside a demo.
  • Listing browser sessions requires SESSION_DRIVER=database. Signing the other sessions out works on any driver.
  • route:cache is deliberately not run: a route closure in routes/settings.php cannot be serialised. config:cache, event:cache and view:cache are.