> ## Documentation Index
> Fetch the complete documentation index at: https://nikita-shkoda.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Indexer
> Stream documents via JSONL bulk import with retries, memory stability, parallel batch processing, and notifications.
Related: Schema, CLI, Observability, Upsert
Stream documents into a physical collection via JSONL bulk import with retries, stable memory, and notifications.
The Indexer focuses on importing documents. It does not create schemas, swap aliases, or enforce retention. Use Schema.apply! (or the schema:apply task) for full blue/green lifecycle: create new physical → import → alias swap → retention cleanup.
### API
```ruby theme={null}
SearchEngine::Indexer.import!(SearchEngine::Book, into: "books_20251001_010203_001", enum: enumerable_batches, batch_size: 2000, max_parallel: 4)
```
* into: physical collection name
* enum: enumerable yielding batches (Arrays of Hash documents)
* batch\_size: soft guard for JSONL production; batches are not re-sliced unless handling 413
* action: defaults to :upsert
* max\_parallel: maximum number of parallel threads for batch processing (default: 1, sequential). Set via mapper DSL with max\_parallel or override at runtime. See Parallel batch processing.
### Data flow
```mermaid theme={null}
flowchart TD
S[Source] --> M[Mapper]
M --> B[Batch JSONL]
B --> I[Bulk upsert]
I --> R[Metrics/Notifications]
```
### JSONL format
* One JSON object per line
* Newline between documents; trailing newline optional
* Strings are escaped by the JSON library
### Retries & backoff
* Transient errors (timeouts, connection, 429, 5xx) are retried with exponential backoff and jitter
* Non-transient errors (401/403/404/400/422) are not retried
* 413 Payload Too Large splits the batch recursively until it fits
### Parallel batch processing
For large collections, you can speed up indexing by processing multiple batches simultaneously using parallel threads. This is especially useful when network latency is a bottleneck.
#### Configuration
Enable parallel processing in your mapper DSL:
```ruby theme={null}
class SearchEngine::Book < SearchEngine::Base
collection "books"
index do
source :active_record, model: ::Book, batch_size: 2000
max_parallel 4 # Process up to 4 batches concurrently
map do |r|
{ title: r.title, author_id: r.author_id }
end
end
end
```
The max\_parallel setting controls how many batches are processed simultaneously. Each thread gets its own Typesense client instance and buffer to avoid conflicts.
#### Usage examples
Basic usage:
```ruby theme={null}
# Parallel processing is automatically enabled when max_parallel > 1 is set in the mapper DSL
SearchEngine::Book.rebuild_partition!(partition: publisher_id)
```
Manual control:
```ruby theme={null}
# Override the DSL setting at runtime
docs_enum = build_docs_enum(rows_enum, mapper)
SearchEngine::Indexer.import!(
SearchEngine::Book,
into: "books_20251001_010203_001",
enum: docs_enum,
max_parallel: 8 # Use 8 threads instead of the DSL default
)
```
When to use:
* Large collections with thousands of batches
* Network latency is the main bottleneck (not CPU or memory)
* Your Typesense server can handle concurrent requests
* You have sufficient memory for multiple buffers
When to avoid:
* Small collections (\< 100 batches)
* CPU-bound workloads (parallel processing adds overhead)
* Very memory-constrained environments
* When debugging (sequential processing has clearer error messages)
#### How it works
Parallel batch processing uses a producer-consumer pattern with a thread pool:
1. Producer thread: Fetches batches from your source (ActiveRecord, SQL, etc.) and adds them to a queue
2. Worker threads: Multiple threads pull batches from the queue and process them concurrently
3. Thread safety: Each worker gets its own Typesense client and buffer to avoid conflicts
4. Statistics: All counters are synchronized using a mutex to ensure accurate reporting
```mermaid theme={null}
flowchart LR
S[Source] --> P[Producer Thread]
P --> Q[Batch Queue]
Q --> W1[Worker 1]
Q --> W2[Worker 2]
Q --> W3[Worker 3]
Q --> W4[Worker 4]
W1 --> TS[Typesense]
W2 --> TS
W3 --> TS
W4 --> TS
```
The queue has a capacity of max\_parallel \* 2 to keep workers busy while the producer fetches more batches.
Interrupt handling (InterruptiblePool):
Parallel imports run inside an InterruptiblePool wrapper that ensures clean shutdown on Ctrl+C.
On normal completion, the pool drains gracefully (up to a configurable timeout). On Interrupt,
worker threads are killed promptly (within 10 seconds) instead of waiting for the full graceful-shutdown
window. This prevents stuck processes during interactive development.
Partition timeout detection:
When the graceful-shutdown timeout is exceeded (default: 3600 seconds), the pool kills remaining workers
and raises SearchEngine::Errors::PartitionTimeout. The error reports which partitions were lost
so operators can identify what needs re-running.
Error handling:
When a batch fails, the error is caught and recorded with full statistics (document count, failure details)
just like in sequential processing. Failed batches are properly counted in the summary's
docs\_total, failed\_total, and batches array to ensure accurate reporting.
When indexation is run inside Schema.apply! (e.g., via .index\_collection), a non-ok
result raises SearchEngine::Errors::IndexationAborted, which prevents the alias swap. The
partially-indexed new physical is automatically cleaned up to prevent orphan accumulation. See
Schema → Failed indexation safety.
### Live progress rendering
On TTY terminals, indexation displays real-time progress using the
LiveRenderer. Each partition gets a dedicated line with a
braille spinner, a doc-based progress bar (when estimates are available),
and elapsed time. The renderer is viewport-aware — when the number of
partitions exceeds terminal height, it switches to a compact mode
showing active slots and a summary header.
Lifecycle steps (Presence, Schema Status,
Indexing, Retention) use
StepLine for in-place overwriting with animated spinners.
On non-TTY environments (CI, pipes, redirected output), the renderer
falls back to static one-line-per-partition completion output, preserving
pipe compatibility.
TTY component reference:
Observability → Live progress (TTY).
### Memory notes
* Operates strictly batch-by-batch, reusing a single buffer per thread
* No accumulation of all records in memory; per-batch array may be materialized to support 413 splitting
* Parallel processing: each worker thread maintains its own buffer and client instance (memory usage scales with max\_parallel)
### Instrumentation
* Emits search\_engine.indexer.batch\_import per attempted batch
* Payload includes: collection, batch\_index, docs\_count, success\_count, failure\_count, attempts, duration\_ms, http\_status, bytes\_sent, transient\_retry, error\_sample
### Dry-run
* SearchEngine::Indexer.dry\_run!(...) builds JSONL for the first batch only and returns `{ collection, action, bytes_estimate, docs_count, sample_line }`
### Data Sources
Adapters provide batched records for the Indexer in a memory-stable way. Each adapter implements each\_batch(partition:, cursor:) and yields arrays.
Examples:
```ruby theme={null}
source :active_record, model: ::Book, scope: -> { where(published: true) }, batch_size: 2000
source :sql, sql: "SELECT * FROM books WHERE published = TRUE", fetch_size: 2000
source :lambda do |cursor: nil, partition: nil|
Enumerator.new { |y| external_api.each_page(cursor) { |rows| y << rows } }
end
```
When source is not :active\_record, you must define
identify\_by on the model. The mapper ignores any id
returned from map, so SQL/lambda rows need an explicit identity
strategy. See
Models.
* partition and cursor are opaque; adapters interpret them per-domain (e.g., id ranges, keyset predicates, external API tokens).
* Instrumentation: emits search\_engine.source.batch\_fetched and search\_engine.source.error.
### Mapper
Backlinks: Models, Schema
```ruby theme={null}
class SearchEngine::Book < SearchEngine::Base
collection "books"
attribute :publisher_id, :integer
attribute :author_id, :integer
attribute :author_name, :string
attribute :price_cents, :integer
# Default identity is record.id.to_s for ActiveRecord sources.
# For :sql or :lambda sources, set identify_by.
# identify_by :isbn
# identify_by ->(r) { "#{r.publisher_id}-#{r.id}" }
index do
source :active_record, model: ::Book, scope: -> { where(published: true) }
map do |r|
# :id from map is ignored; mapper injects computed id
{ publisher_id: r.publisher_id, author_id: r.author_id, author_name: r.author&.name, price_cents: r.price_cents }
end
end
end
```
Model → Document mapping:
| Model field | Document field | Transform |
| -------------- | -------------- | ------------------------ |
| `id` | `id` | identity |
| `publisher_id` | `publisher_id` | identity |
| `author_id` | `author_id` | identity |
| `author.name` | `author_name` | rename + safe navigation |
| `price_cents` | `price_cents` | identity |
Validation:
* Missing required fields: the mapper validates declared attributes; id is injected and not required to be declared.
* Unknown fields: warns by default; set SearchEngine.config.mapper.strict\_unknown\_keys = true to error.
* Type checks: invalid types reported (e.g., Invalid type for field :price\_cents (expected Integer, got String: "12.3").).
* Coercions: enable with SearchEngine.config.mapper.coercions\[:enabled] = true (safe integer/float/bool only).
#### Array empty filtering (hidden flags)
If an array attribute is declared with empty\_filtering: true, the mapper auto-populates a hidden boolean \\_empty per document:
```ruby theme={null}
attribute :category_ids, [:string], empty_filtering: true
# Mapper stores: category_ids_empty = category_ids.nil? || category_ids.empty?
```
Hidden fields are included in the schema and documents but are not exposed via model APIs/inspect.
Runtime API:
* mapper = SearchEngine::Mapper.for(SearchEngine::Book)
* docs, report = mapper.map\_batch!(rows, batch\_index: 1)
* Emits search\_engine.mapper.batch\_mapped per batch with: collection, batch\_index, docs\_count, duration\_ms, missing\_required\_count, extra\_keys\_count, invalid\_type\_count, coerced\_count.
### Partitioning
Backlinks: Schema, CLI, Observability
```ruby theme={null}
index do
partitions { Publisher.pluck(:id) }
partition_fetch { |publisher_id| ::Book.where(publisher_id: publisher_id).in_batches(of: 2000) }
before_partition { |publisher_id| delete_by filter_by: "publisher_id:=#{publisher_id}" }
after_partition { |publisher_id| nil } # custom metrics
end
```
```ruby theme={null}
SearchEngine::Indexer.rebuild_partition!(SearchEngine::Book, partition: publisher_id)
```
#### Model-level shortcut
You can call the same operation directly on the collection model. This delegates to the Indexer and returns the same SearchEngine::Indexer::Summary (or an Array when multiple partitions are provided).
```ruby theme={null}
SearchEngine::Book.rebuild_partition!(partition: publisher_id)
SearchEngine::Book.rebuild_partition!(partition: publisher_id, into: "optional_physical_collection")
# Multiple keys return an Array:
SearchEngine::Book.rebuild_partition!(partition: [1, 2, 3])
```
#### Summary return value
SearchEngine::Indexer::Summary includes:
* collection: logical collection name
* status: :ok, :partial, or :failed
* batches\_total: total number of batches processed
* docs\_total: total documents processed
* success\_total: successfully indexed documents
* failed\_total: failed documents
* failed\_batches\_total: count of batches with failures
* duration\_ms\_total: total wall-clock duration in milliseconds
* batches: array of per-batch stats
```mermaid theme={null}
sequenceDiagram
participant Orchestrator
participant Partition
Orchestrator->>Partition: before_partition
Orchestrator->>Partition: import batches
Orchestrator->>Partition: after_partition
```
Notes:
* partitions must return an Enumerable of keys; partition\_fetch must return an Enumerable of batches (Arrays of records).
* Hooks are optional; if provided, they must accept exactly one argument (the partition key).
* When partition\_fetch is missing, the source adapter is used with the partition passed through; for ActiveRecord sources, provide a Hash/Range partition or define partition\_fetch.
### Model indexation (`.index_collection`)
Backlinks: Schema, CLI, Observability, Models
High-level convenience API that orchestrates schema lifecycle and (partitioned) indexing from the model class.
```ruby theme={null}
# Full indexation flow (create/apply schema if needed, reindex, retention)
SearchEngine::Book.index_collection
# Partial indexation by key(s) (requires collection present and schema in-sync)
SearchEngine::Book.index_collection(partition: publisher_id)
SearchEngine::Book.index_collection(partition: [publisher_id_1, publisher_id_2])
```
Behavior:
* Full flow when partition is nil:
1. Presence check (Schema.diff).
2. If missing → create new physical and apply schema, then import; else skip.
3. If present → check drift; report in\_sync vs drift.
4. If drift → apply schema (create new physical, import, alias swap, retention).
5. If nothing was applied in steps 2–4 → index into the current alias (single or per partition).
6. Retention cleanup: skipped when Schema.apply! ran (already handled); otherwise best‑effort cleanup of old physicals beyond keep\_last.
* Partial flow when partition: is set:
1. Presence check; if missing → quit early with a message.
2. Schema status; if drift → quit early with a message to run full indexation.
3. Index only the provided partition(s) into the current alias.
#### Preflight dependency indexation (optional)
You can ask the engine to walk direct and transitive belongs\_to dependencies and ensure they are ready before indexing the current collection:
```ruby theme={null}
# Ensure dependencies exist (create/apply+index only when missing)
SearchEngine::Book.index_collection(pre: :ensure)
# Ensure dependencies exist and also fix drift (apply+index when missing or drift)
SearchEngine::Book.index_collection(pre: :index)
# Partial with preflight
SearchEngine::Book.index_collection(partition: publisher_id, pre: :ensure)
```
Notes:
* Preflight walks only belongs\_to edges recursively, skipping unregistered collections.
* Cycles are guarded with a visited set; already-visited collections are skipped.
* Default remains unchanged when pre: is omitted.
Output
* Emits concise console lines for each step and per‑partition result, for example:
```text theme={null}
Step 1: Presence — processing → present
Step 3: Check Schema Status — in_sync
Step 5: Indexation — processing
partition=123 → status=ok docs=2000 failed=0 batches=10 duration_ms=1523.4
Step 5: Indexation — done
Step 6: Retention Cleanup — skip (handled by schema apply)
```
Sequence
```mermaid theme={null}
sequenceDiagram
participant App
participant Schema
participant Indexer
participant TS as Typesense
App->>Schema: diff
alt missing || drift
Schema->>TS: create new physical
Indexer->>TS: bulk import into new physical
Schema->>TS: alias swap + retention
else in_sync
Indexer->>TS: bulk import into current alias target
App->>TS: retention (best-effort)
end
```
### Targeted bulk helpers (`Bulk.index_collections` / `Bulk.reindex_collections!`)
* Run blue/green or destructive indexation for a specific set of collections (not just “all”).
* Two-stage plan:
* **Stage 1**: inputs that are not referrers of other inputs (referenced-first order).
* **Stage 2**: unique referencers of any input, topologically sorted and processed once.
* Cascades are suppressed inside individual runs; the final cascade stage handles referencers exactly once.
```ruby theme={null}
# Blue/green selected collections
SearchEngine::Bulk.index_collections(:books, :publishers)
# Destructive reindex of a subset with an injected client
SearchEngine::Bulk.reindex_collections!(
SearchEngine::Book,
"authors",
client: SearchEngine.client
)
```
Use these helpers when you need a targeted rollout (only changed collections) but still want reference-aware ordering.
#### Return value
Bulk.index\_collections and Bulk.reindex\_collections! return a hash with:
* mode: :index or :reindex
* inputs: array of input collection names
* stage\_1: array of stage 1 collection names
* cascade: array of cascade stage collection names
* inputs\_count: number of input collections
* stage\_1\_count: number of stage 1 collections
* cascade\_count: number of cascade collections
* failed\_collections\_total: count of unresolved collection targets
### Bulk indexing (all collections)
Use Bulk helpers to index or reindex every declared SearchEngine collection discovered under your configured search\_engine\_models directory. The engine ensures models are eagerly loaded, discovers collections, and orchestrates a two‑stage, reference‑aware run (inputs first, then a deduped cascade of referencers).
```ruby theme={null}
# Non‑destructive (blue/green when needed via .index_collection per model)
SearchEngine::Bulk.index_all
# Destructive: drop + index per model
SearchEngine::Bulk.reindex_all!
# Optional client override
SearchEngine::Bulk.index_all(client: SearchEngine.client)
```
Notes:
* index\_all uses each model's .index\_collection (presence/drift checks, apply+retention when needed; otherwise index into current alias).
* reindex\_all! uses each model's .reindex\_collection! (drop active physical, then .index\_collection).
* Discovery leverages the engine’s dedicated loader and CollectionResolver.models\_map; ensure your collections live under app/search\_engine (default) or your configured SearchEngine.config.search\_engine\_models path.
* Emits search\_engine.bulk.run with `{ inputs, stage_1, cascade, counts, failed_collections_total }`. See Observability for payload details.
* Return value: same hash structure as Bulk.index\_collections / Bulk.reindex\_collections!, including failed\_collections\_total.
Backlinks: Models · Schema · Observability
### Stale Deletes
Backlinks: CLI, Observability, Troubleshooting, Configuration
Define stale rules once. The same compiled filter powers .stale,
.cleanup, Indexer.delete\_stale!, and index:delete\_stale.
```ruby theme={null}
class SearchEngine::Order < SearchEngine::Base
index do
# Register one or more stale rules; they will be OR‑merged
stale scope: :cancelled # scope must return a Relation
stale :archived # attribute equality => { archived: true }
stale filter: "status:=cancelled" # raw Typesense fragment
stale({ ends_at: ..Time.zone.now })
stale do |partition:| # custom per‑partition rule
partition ? { store_id: partition, archived: true } : "archived:=true"
end
end
end
```
```ruby theme={null}
SearchEngine::Indexer.delete_stale!(SearchEngine::Order, partition: 42)
```
* Compiles all declared stale rules into an OR‑merged filter\_by string and issues DELETE /collections/:collection/documents with filter\_by.
* If no rules are defined or all resolve to blank for the given partition, deletion is skipped.
* Strict-mode guardrails block suspicious catch-alls; enable via SearchEngine.config.stale\_deletes.strict\_mode = true.
* Dry-run preview: SearchEngine::Indexer.delete\_stale!(..., dry\_run: true) returns a summary without deleting.
Typical filters:
| Pattern | Example |
| -------------------- | ------------------------------------------------------------------------------------------ |
| Archived flag | archived:=true |
| Partition + archived | store\_id:=123 && archived:=true |
| Date threshold | updated\_at:\<"2025-01-01T00:00:00Z" or updated\_at:\<1704067200 |
```mermaid theme={null}
sequenceDiagram
participant Orchestrator
participant Partition
Orchestrator->>Partition: before_partition
Orchestrator->>Partition: import batches
Orchestrator->>Partition: after_partition
```
Events:
* search\_engine.stale\_deletes.started — `{ collection, into, partition, filter_hash }`
* search\_engine.stale\_deletes.skipped — `{ reason, collection, into, partition }`
* search\_engine.stale\_deletes.finished — `{ collection, into, partition, duration_ms, deleted_count }`
* search\_engine.stale\_deletes.error — `{ collection, into, partition, error_class, message_truncated }`
Config:
#### Inspect stale docs via a Relation
You can preview or chain on the stale set using a scope-like class method that returns a Relation:
```ruby theme={null}
# Partition-specific stale docs compiled from `stale` rules
SearchEngine::Order.stale(partition: 42)
# Whole-collection stale docs (if none of the rules depend on partition)
SearchEngine::Order.stale
# Chainable like AR
SearchEngine::Order.stale(partition: 42).limit(10).pluck(:id)
```
Notes:
* .stale compiles only stale rules and returns an empty relation when no rules produce a filter for the given partition (implemented as a safe, always‑false filter so Typesense never 400s).
* For destructive deletes, prefer Model.cleanup or the index:delete\_stale task.
* SearchEngine.config.stale\_deletes.enabled = true
* SearchEngine.config.stale\_deletes.strict\_mode = false
* SearchEngine.config.stale\_deletes.timeout\_ms = nil
* SearchEngine.config.stale\_deletes.estimation\_enabled = false
### Stale cleanup DSL & model helper
Define stale cleanup rules alongside your index DSL. Each stale call registers
one rule; cleanup runs them with OR semantics and uses the same compiled filter as
Indexer.delete\_stale!.
```ruby theme={null}
class SearchEngine::Book < SearchEngine::Base
collection "books"
index do
stale scope: :archived # reuse a model scope (must return a Relation)
stale :marked_as_stale # attribute equality => { marked_as_stale: true }
stale filter: "status:=archived" # raw Typesense fragment
stale({ ends_at: ..Time.zone.now }) # hash converted via Sanitizer
stale do |partition:| # custom filter per partition
partition ? "store_id:=#{partition} && archived:=true" : "archived:=true"
end
map do |record|
# ...
end
end
end
```
Runtime cleanup is available directly on the model:
```ruby theme={null}
# Deletes documents matching any declared stale rules
SearchEngine::Book.cleanup
SearchEngine::Book.cleanup(partition: 42)
SearchEngine::Book.cleanup(into: "books_20251011_120000_001")
# Clear Typesense cache after cleanup
SearchEngine::Book.cleanup(clear_cache: true)
```
SearchEngine::Base.cleanup delegates to SearchEngine::Deletion.delete\_by, emitting the same search\_engine.indexer.delete\_stale instrumentation. When no stale configuration exists, it logs a skip and returns 0.
Pass clear\_cache: true to clear the Typesense search cache after cleanup
finishes. This invokes SearchEngine::Cache.clear and emits
search\_engine.cache.clear. Failures are logged and do not affect the cleanup
result.
Available stale inputs:
| Form | Result | | |
| ---------------------------------------------------------------------------------- | ---------------------------------------------------- | ------- | ------------------------------------------- |
| stale scope: :archived | Invokes a model scope; must return a Relation | | |
| stale :flagged / stale attribute: :flagged, value: false | Attribute equality Hash | | |
| `stale({ flag: true, archived: true })` | Sanitized filter\_by hash | | |
| stale filter: 'status:=archived' | Raw Typesense filter string | | |
| stale relation | Uses the relation’s compiled filter\_by | | |
| \`stale do | partition: | … end\` | Custom block returning String/Hash/Relation |
Notes:
* Multiple rules are OR‑ed together.
* Block arguments receive partition:; return a String, Hash, or Relation. nil/blank results are ignored.
* Scope helpers receive the partition as the first positional argument when their arity is ≥ 1, or as partition: when they declare a keyword.
* Attribute Hash inputs default values to true when omitted (e.g., stale :flagged).
See also: Deletion for low-level helpers and Observability for emitted events.
### Dispatcher
Backlinks: CLI, Observability, Configuration, Jobs
```ruby theme={null}
SearchEngine.configure do |c|
c.indexer.dispatch = :active_job # or :inline
c.indexer.queue_name = "search_index"
end
```
* What it does: routes per-partition rebuilds either synchronously (inline) or via ActiveJob.
* Note: This setting controls SearchEngine::Indexer logic (used by rebuild\_partition!, index\_collection flow). It does not affect ActiveRecordSyncable callbacks, which are always inline.
* API: `SearchEngine::Dispatcher.dispatch!(SearchEngine::Book, partition: key, into: nil, mode: nil, queue: nil, metadata: {})`
* Returns an object describing the action: for ActiveJob `{ mode: :active_job, job_id, queue, collection, partition, into }`; for inline `{ mode: :inline, collection, partition, into, indexer_summary, duration_ms }`.
* Mode resolution: mode || SearchEngine.config.indexer.dispatch with a fallback to :inline if ActiveJob is unavailable.
* Queue name: taken from queue || SearchEngine.config.indexer.queue\_name.
ActiveJob job: SearchEngine::IndexPartitionJob.
* Args: collection\_class\_name (String), partition (JSON-serializable), optional into (String), optional metadata (Hash).
### When to choose model-level upserts
For light-touch updates or small repair batches, the model helpers described in Upsert
are often faster than orchestrating a full Indexer run:
* Single or sparse fixes — use SearchEngine::Model.upsert(record: ...) to map and stream one document without building custom JSONL buffers.
* Small batches — SearchEngine::Model.upsert\_bulk(records: ...) streams an enumerable of records through the mapper and client, reusing the same validation path as the Indexer.
* Blue/green touch-ups — the helpers accept into: / partition: to target a specific physical collection during staged rollout.
Reach for the Indexer when you need full rebuilds, partition orchestration, retry/backoff logic, or instrumented batch statistics. Use the upsert helpers when you only need to nudge a handful of documents into place.
## Troubleshooting
* Bulk import shape errors: Ensure each document is a flat Hash with required keys and valid types.
* Retry exhaustion: Inspect search\_engine.indexer.batch\_import events; increase backoff or fix upstream issues.
* Stale deletes strict block: Verify your filter is not a catch-all; use partition guards.
* PartitionTimeout: The parallel pool exceeded its graceful-shutdown timeout. Check for slow partitions or increase timeout\_ms in config.
* IndexationAborted (alias not swapped): Indexation returned a non-ok status during
Schema.apply!. Inspect the new physical for import errors and retry. See
Schema → Failed indexation safety.
Backlinks: CLI, Troubleshooting