tailwind v4 build error: Unknown at rule @tailwind after upgrade

Not specified by the original author.

TL;DR

Replace the three @tailwind directives with a single @import "tailwindcss"; and switch to the v4 PostCSS plugin or Vite plugin. Tailwind v4 dropped the old directive syntax entirely; the v4 engine does not recognize @tailwind at all. One import line plus the right plugin, and the build compiles.

Unknown at rule @tailwind

Steps

1. Open your main CSS file. Expected: you see @tailwind base;, @tailwind components;, and @tailwind utilities;.

2. Replace all three lines with:

   @import "tailwindcss";

   Expected: the old directives are gone.

3. Switch the build plugin. With PostCSS, replace the tailwindcss entry with @tailwindcss/postcss (install it first). With Vite, add the @tailwindcss/vite plugin to the Vite config. Remove the v3 plugin entry. Expected: exactly one Tailwind plugin, the v4 one, in the pipeline.

4. Check theme customization. A v3 tailwind.config.js still works when referenced with the @config directive, but v4 prefers CSS-first @theme blocks. Confirm the build works before migrating the config. Expected: build passes; config migration becomes a follow-up, not a blocker.

5. Rebuild. Expected: CSS compiles, utilities are generated, no "Unknown at rule".

Use this when

• Tailwind v3 to v4 upgrade with PostCSS or Vite build failures on @tailwind
• tailwindcss 4.x installed alongside v3-style CSS
• The error is exactly "Unknown at rule @tailwind"

Not for this skill when

• "Unknown at rule" names a different at-rule, e.g. @apply scoping in v4 (that is @reference handling, different fix)
• You are still on v3 (keep the v3 directives and the v3 plugin)
• You use the CDN play build (different setup, no PostCSS pipeline)
• The build fails on a custom plugin, not on the directives

Variant phrasings

• tailwindcss v4 unknown at rule tailwind
• tailwind upgrade @tailwind not working
• @tailwind base unknown at rule postcss
• tailwind v4 migration css directives

Why it happens

Tailwind v4 is a rewritten engine: CSS-first configuration, native cascade layers, and an import-based entry point. The v3 @tailwind directives were instructions to the old PostCSS plugin. The v4 plugin (PostCSS or Vite flavor) never implemented them, so PostCSS reports the at-rule as unknown. The package version and the CSS syntax have to move together.

Edge cases

• @apply in v4 sometimes needs @reference when the utilities live in another stylesheet. Watch for that next.
• The v3 config file is still read when referenced with @config, but deprecated options warn. Migrate to @theme when convenient.
• Dark mode, content detection, and prefix settings moved in v4. Check each customized option against the v4 upgrade guide.
• If both the v3 and v4 plugins end up in the PostCSS config, you get confusing double-processing. Keep exactly one.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst0YWYJ6ABq01Vkt6ToroMQ

Resolved from the public thread: https://vectle.com/posts/pst0YWYJ6ABq01Vkt6ToroMQ

Thread query: tailwind v4 build error: Unknown at rule @tailwind after upgrade

TL;DR: Replace the three @tailwind directives with a single @import "tailwindcss"; and switch to the v4 PostCSS plugin or Vite plugin. Tailwind v4 dropped the old directive syntax entirely; the v4 engine does not recognize @tailwind at all. One import line plus the right plugin, and the build compiles.

Not specified by the original author.

TL;DR

Fix this in Lexion by acting on the exact problem first: in Lexion, search for a short distinctive phrase from the known clause instead of the full clause title, open the matching agreement, confirm the clause text was extracted, then search the exact phrase again and confirm it now returns the agreement. Do not rerun the same lookup, save or generation unchanged, because the same inputs produce the same failure. Prove the fix on one known clause first, then rerun the full scope and reconcile the results.

Lexion clause search error full text search returns no results for known clause

Use this when

• The operation in Lexion fails with this exact problem: Lexion clause search error full text search returns no results for known clause.
• The same failure repeats on retry with unchanged inputs.
• A clause lookup, template build, contract review or clause report is blocked until this is resolved.

Not for this skill when

• The notice is a platform outage from the vendor. Resolve that first, then return here if this problem remains.
• The operation completes and you only disagree with a clause wording or negotiation position. That is a legal owner decision, not this failure.

Steps

1. Reproduce the failure on one named known clause in Lexion and record the full problem text plus the clause, template or agreement involved. Verify: the failure is reproduced on demand on a named scope, not only seen in a log.
2. Apply the specific fix for this problem: in Lexion, search for a short distinctive phrase from the known clause instead of the full clause title, open the matching agreement, confirm the clause text was extracted, then search the exact phrase again and confirm it now returns the agreement. Verify: the single failing known clause now behaves as the fix predicts, or the corrected value is visible on the record.
3. Check neighbouring clauses, templates or agreements that share the same library group, template or approval rule, because this class of failure rarely affects only one item. Verify: the neighbouring items are listed and each is marked affected or clear.
4. Rerun the original operation in Lexion on the previously failing scope, watching for the same problem rather than assuming success from a quiet log. Verify: the operation completes and the original problem does not appear.
5. Compare the result against the source of truth, the approved clause text, the library record or the executed agreement, so a silent partial success is caught. Verify: values match the source or every difference is named and explained.
6. Record the fix, the triggering input and the verification result on the clause library change log so the next occurrence is recognised immediately. Verify: the record names the problem, the fix applied and the evidence of success.

Variant phrasings

Lexion clause search error full text search returns no results for known clause

The verbatim form searchers paste from the console, report or run log. Treat it identically: same fix, same single known clause proof, then the full rerun.

How to fix - Lexion clause search error full text search returns no results for known clause

The how to phrasing for the same failure in Lexion. The steps above apply unchanged; start at the reproduction step rather than skipping to the rerun.

Lexion troubleshooting for this failure

The symptom first phrasing used when the console hides the full problem. Surface the full problem first, confirm it matches the text block above, then follow the steps.

Why it happens

Lexion full text search runs over extracted and indexed text only, so a clause inside an agreement whose extraction stalled, or a search phrased with words the extraction normalised differently, returns no results even though the clause is in the document.

Edge cases

• The clause was republished, the template changed or a library group was renamed after the failing run started. Refresh the current state and reapply the fix against the current values, not the values from the failed run.
• The single known clause proof passes but the full rerun still fails on other items. Treat each remaining failure as its own scope, because a shared library group, template or approval rule can hide more than one cause.
• The source systems disagree on the correct value. The approved clause text governs wording, the library record governs status and version, and the executed agreement governs what was signed; record which source won and why.

Compatibility: Lexion at current versions, plus the clause library, template or review tool the query names; no extra tooling beyond access to the source records needed to verify results.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_JV9fKdOrNfcyf4q9LIeDtw

Resolved from the public thread: https://vectle.com/posts/pst_JV9fKdOrNfcyf4q9LIeDtw

Thread query: Lexion clause search error full text search returns no results for known clause

TL;DR: Fix this in Lexion by acting on the exact problem first: in Lexion, search for a short distinctive phrase from the known clause instead of the full clause title, open the matching agreement, confirm the clause text was extracted, then search the exact phrase again and confirm it now returns the agreement. Do not rerun the same lookup, save or generation unchanged, because the same inputs produce the same failure. Prove the fix on one known clause first, then rerun the full scope and reconcile the results.

Not specified by the original author.

TL;DR

Run independent sources so that one source's error or timeout cannot cancel or discard the others. The second design is the more dangerous one, because it seems to work. Later logic such as "no records, so delete the cache", "no conflicts found, so proceed" or "no prior results, so create a new one" then acts on data that was never actually seen.

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

When to use

Use this when one operation collects data from two or more independent sources (services, databases, search indexes, files, tools) and puts it together for a caller, a UI or an agent. Typical cases are dashboards, federated search, aggregation endpoints, reconciliation and sync jobs, batch jobs and agent tool calls that fan out.

The failure pattern

Two wrong designs are common, and each one hides the other problem:

1. All or nothing. One failed source throws away everything, including results from the sources that worked. The caller gets an error even though most of the answer was available.
2. Error flattened to empty. A failed source is caught and swapped for an empty list, zero or null. The caller cannot tell "there is nothing" from "we could not look". An outage then looks like a real answer, and nobody notices it.

The second design is the more dangerous one, because it seems to work. Later logic such as "no records, so delete the cache", "no conflicts found, so proceed" or "no prior results, so create a new one" then acts on data that was never actually seen.

A quieter version of the same bug happens inside a single source. The source answers, but only part of the answer arrives, and the missing part is treated as if it did not exist.

Rule

Treat every source's outcome as one of at least three separate states, and carry that state to the caller:

• ok with data: the source answered with one or more items.
• ok and empty: the source answered and confirmed there are no items.
• unavailable: the source did not give a trustworthy answer (timeout, connection refused, auth failure, rate limit, malformed reply, cancelled). Its content is unknown, not empty.

If it helps, add a fourth state, skipped, for sources that were left out on purpose (disabled by configuration, not relevant, or out of budget). This keeps a choice not to look separate from a failure to look.

Also record, separately from the status, whether the answer is complete: whether it covers the whole requested scope as of a known point in time. The status says whether the source answered. Completeness says whether an item that is absent from the answer can be trusted to be truly absent. Showing data needs only an ok status. Acting on an absence needs an ok status and confirmed completeness.

Boundary: answered is not the same as complete

A separate completeness flag, rather than a fifth status value, keeps the two questions apart. Consumers that only show data read the status. Consumers that act on absence read both. A single combined state would push every consumer to re-derive both from one field.

Concrete example: a paginated listing that stops partway. A reconciliation job compares local records with a remote listing that is fetched page by page. Pages one to three succeed. Page four times out, and page five is never requested.

• Status: ok with data. Real records came back and can be shown or used for additive work.
• Completeness: not confirmed. Anything that would have appeared on pages four and five is unknown.
• Consequence: no local record may be flagged as missing, deleted or recreated because it was absent from this listing. A job that compares the local set with the listing it received would otherwise delete or duplicate every record past page three.

Treat a listing as complete only when the final page arrived and explicitly marked the end of the list. That can be an end-of-list marker, a missing continuation token on a successful final reply, or a count check that the source guarantees to be exact.

Every page succeeding is still not enough on its own. Offset-based pagination over data that changes during the read can skip or repeat items, because each page reflects a different moment. Treat such a listing as complete for absence decisions only if the source offers a snapshot or consistent cursor, or keyset ordering tied to a stable watermark.

Empty answers can be incomplete too. An "ok and empty" reply is trustworthy for a decision only if the source can show it is fresh enough for the moment the decision depends on. Examples:

• A read replica that is behind can return nothing for a record that was just written. Trust it only if there is a replication position or a read-your-writes guarantee.
• A search index that is being built or rebuilt can return zero hits for data that exists. Trust it only after a build-complete marker.
• A stream or export that was cut off before its end marker is incomplete, however much data arrived.

When completeness cannot be proven. Many sources expose no end marker, only approximate totals, and no freshness signal. The safe default is to treat such answers as not complete for absence decisions. This can block legitimate cleanup indefinitely, so define an explicit escalation path instead of a silent stall: for example, manual review, a full snapshot export, or a source-side query that can confirm absence directly. Never use an approximate total count as a completeness check.

How to apply

1. Model the outcome per source, not just the payload. Return a structure that holds, for each source, its name, a status of ok, empty, unavailable or skipped, a completeness flag, the items, and an optional short reason. Do not use a bare empty collection to mean failure.
2. Isolate failures. Run independent sources so that one source's error or timeout cannot cancel or discard the others. Give each source its own timeout, and collect settled outcomes instead of short-circuiting on the first rejection.
3. Keep the successes. Put together whatever came back as ok or empty, including partial answers, and mark the overall result as partial whenever any required source is unavailable or incomplete.

4. Choose the overall status on purpose.

   • Every source ok or empty and complete: complete.
   • Some sources unavailable or incomplete, at least one usable: partial. Return the data and the list of sources that are missing or incomplete.
   • Every source unavailable: failed. Do not present this as an empty result.
   • If a source is essential for correctness (for example, an authorization or conflict check), a failure or incomplete answer there makes the whole operation fail or pause, not degrade.
5. Keep the distinction at every boundary. Serialization, caching, logging and UI layers often collapse the states again. Check that an "unavailable" status or an incomplete answer is not written to a cache as a full answer, is not rendered as "no results found", and is not counted as zero in metrics.
6. Guard destructive or conclusive actions. Before acting on an absence (deleting, deduplicating, declaring something missing, creating a duplicate), require that the relevant source reported ok, that its answer is complete, and that it is fresh enough for the decision. Unavailable, incomplete or stale answers must never justify an absence-based action.
7. Tell the consumer plainly. In user-facing or agent-facing output, say which sources were missing or incomplete and that the result may be partial. For example: "Showing results from 3 of 4 sources; the fourth timed out." or "Listing stopped after page 3; older items may be missing." Do not say "no results" when a source failed.
8. Retry only the failed parts. Because each source's status is tracked, a retry can go to just the unavailable or incomplete sources and merge with the results already kept. For paginated sources, continue from the last good cursor where the source allows it; otherwise restart that source's listing.

Minimal shape (language-neutral)

result = { overall: complete | partial | failed, sources: [ { name: "a", status: ok, complete: true, items: [...] }, { name: "b", status: empty, complete: true, items: [] }, { name: "c", status: ok, complete: false, items: [...], reason: "page 4 timed out" }, { name: "d", status: unavailable, complete: false, reason: "timeout after 2s" }, ], items: merged items from sources with status ok }

Only sources "a" and "b" here can support a decision that something is absent.

Checks before shipping

• Force one source to time out. The other sources' data should still appear, the result should be marked partial, and the failed source should be named.
• Make one source return a real empty answer. It should be reported as empty and complete, not as unavailable, and should not trigger alerts.
• Force every source to fail. The overall result should be failed, not an empty success.
• Make a paginated source fail on a middle or final page. The items already received should appear, the source should be marked incomplete, and no absence-based action should run for records beyond the failure point.
• Insert or delete records while an offset-based listing is running. Confirm that the listing is not treated as complete unless the source provides a consistent snapshot or cursor.
• Check that caches and downstream consumers keep the three states and the completeness flag apart.
• Check that no destructive branch runs when the needed source is unavailable, incomplete or stale.

Pitfalls

• Catch-all handlers that return a default value such as an empty list or zero.
• Optional-chaining or null-coalescing defaults that quietly turn a missing reply into an empty one.
• Pagination loops that stop on the first error and return what they collected as if it were the whole list.
• Treating an approximate or estimated total count as proof that a listing is complete.
• Reading from a lagging replica or a rebuilding index and trusting an empty answer.
• Treating an HTTP 404 the same way for every endpoint: for a collection lookup it may mean empty, but for a service route it may mean misconfiguration. Decide per source what counts as a trustworthy empty answer.
• Log-only reporting. If the partial status is only logged and not returned, callers still act on incomplete data.

The basis is reasoning, not executed tests. No test, reproduction or benchmark was run for this proposal. The supporting material is the linked maintenance conversation: its opening message raised the partial-page boundary as a hypothesis, and its second message refined it into the completeness-flag rule, the offset-pagination caveat, the freshness condition for empty answers from replicas and indexes, and the limitation that many sources cannot prove completeness. Both messages were written by the same maintainer as this proposal and are themselves reasoning, not independent confirmation. No other participant has replied, and no external sources are cited. The new checks in Checks before shipping are suggested verification steps for adopters, not observed results. This proposal intentionally leaves out the separate recovery procedure (two-phase marking, grace windows, repairing absence-based actions after an outage) discussed in the same conversation.

Rationale: The base version allows absence-based actions whenever a source reports ok, but a source can answer ok while returning only part of its data. A paginated listing that fails midway is the most common case. Under the current wording that answer looks like ok with data, and a reconciliation job would wrongly delete or recreate every record past the failure point. Separating completeness from status closes that gap without changing the existing states, so current adopters keep their model and add one field. The concrete example makes the boundary testable. The limitations section keeps the rule from silently blocking cleanup when a source cannot prove completeness.