Adds defineIndexTypes() factory builder and createIndexTypeRegistry()
in @prisma-next/sql-contract/index-types. The builder declares each
type literal exactly once and exposes both a phantom IndexTypes map
(for type-level narrowing) and a runtime entry list. The registry is
instance-based — created per contract assembly, not module-global —
so two contracts with different pack lists see different valid type
sets. No consumers wired yet.

Also clarifies ADR 210: the per-contract registry is assembled from
each pack's entries during contract definition, not via global
register() calls at module load.

Lockstep rename across the IR, the SQL family validator, the schema-IR,
the TS authoring surface (IndexOptions, IndexConstraint, IndexNode,
contract-lowering, build-contract), and the contract emitter. The
schema-IR SqlIndexIR gains the new fields. The ParadeDB bm25Index()
helper writes the new field names but is otherwise untouched (full
removal happens when the registry is wired in M3).

The placeholder fields are inert in every active code path today, so
this rename is observationally silent. No backwards-compatibility
shim.

…ntract definition

ExtractIndexTypesFromPack pulls the phantom __indexTypes off any pack
that carries one. AllIndexTypeLiterals walks all literal keys across a
record of packs, and MergeExtensionIndexTypes builds the merged map by
looking each literal up in its contributing pack. IndexTypesFromDefinition
folds target + extension packs into a single record and feeds it through
MergeExtensionIndexTypes. SqlContractResult exposes the merged map as
a phantom __indexTypes? field.

The implementation deliberately avoids UnionToIntersection so the empty
case resolves cleanly to Record<never, never> rather than the
UnionToIntersection<never> = unknown footgun.

Type tests cover single-pack extraction, fall-through for packs without
__indexTypes, multi-pack merging, definition-level resolution, and the
end-to-end defineContract path.

validateContract grows an optional indexTypeRegistry option. When
supplied, validateSqlStorage looks up each index's type in the
registry, validates options against the registered arktype validator,
and rejects unknown types or options that fail validation. Even when no
registry is supplied, options-without-type is still rejected.

Test coverage: registered+valid passes, unregistered type rejects with
the type name, invalid option fails with arktype path, strict-mode extra
key rejects, options-without-type rejects, no type/options accepts, no
registry skips type lookup but still rejects options-without-type.

…ions are set

createIndex grows an optional extras argument carrying type and options.
When supplied, it emits CREATE INDEX <name> ON <table> USING <method>
(<cols>) WITH (<key> = <literal>, ...). The framework owns the renderer:
strings are escapeLiteral-quoted, finite numbers stringify, booleans
emit true/false, and any other leaf shape (null, NaN, objects) throws.

CreateIndexCall and renderTypeScript carry the new args verbatim; the
issue planner threads contract index.type / index.options through.
Existing callers without extras get the same plain CREATE INDEX as
before.

Tests: 8 DDL emission cases in index-ddl.test.ts (plain, USING-only,
USING+WITH, empty options, mixed scalars, single-quote escape, null
rejection, NaN rejection) plus a renderTypeScript case for the new
extras argument shape.

…ema indexes

verifyIndexes now treats type and options as part of an index's identity.
A contract index with type "gin" no longer matches a schema index that
has columns the same but type "btree" (or no type at all); instead the
verifier emits index_mismatch (the contract index needs creation) plus
extra_index in strict mode (the schema index needs to be dropped). The
issue planner naturally translates this pair into DROP + CREATE — the
spec'd behavior for any change to columns / type / options.

Unique constraints can only satisfy a contract index requirement when
that requirement does not specify a type or options, since a unique
constraint carries no index-method or storage-parameter information of
its own.

Tests: three new cases in schema-verify.semantic-satisfaction.test.ts —
type differs (mismatch + extra), options differ (mismatch + extra), and
type/options match exactly (no issues). The createContractTable /
createSchemaTable helpers grow optional type / options fields so the
index inputs accept the new shape.

…ry; drop helpers

Replace the bespoke bm25Index() helper, the bm25 namespace
(text/numeric/boolean/json/datetime/range/expression builders), the
Bm25*FieldConfig / *FieldOptions types, the TokenizerId catalog, and
the rich Bm25IndexConfig with a single defineIndexTypes().add("bm25",
{ options }) registration. The arktype validator narrows options to
{ key_field: string } in strict mode; per-field tokenizer / column
configuration is deferred to expression-index support.

paradedbPackMeta exposes the resulting __indexTypes phantom map so
SqlContractResult can narrow constraints.index({ type: "bm25" }) at
the call site, and exposes the registry entries on indexTypes so
contract assembly can register them at validation time.

Tests rewritten around the new shape: pack identity + capability
checks, single-entry verification, and the four validator paths
(valid options, missing key_field, extra key, wrong type).

Adds @prisma-next/sql-contract and arktype to paradedb deps.

…pe, options })

Threads the merged IndexTypes map all the way to the constraints DSL
inside .sql(({ constraints }) => ...) so wrong index type literals and
wrong option shapes surface as TS errors on the offending
constraints.index(...) line — not buried in a deep defineContract type.

Wiring:
- ContractModelBuilder gains a sixth generic IndexTypes (default wildcard)
- SqlContext<Fields, IndexTypes> picks PackAwareSqlConstraints<IndexTypes>
- A discriminated-union IndexInput<Name, IndexTypes> rejects unregistered
  types and bad option shapes; "options without type" is also rejected
  via the type?: never branch
- ComposedAuthoringHelpers.model becomes PackAwareModel<MergeAllPackIndexTypes>
  so the helpers form (defineContract({...}, ({ model }) => ...)) carries
  the merged map; the bare model() import keeps the wildcard default to
  preserve backward compat

The runtime is unchanged — narrowing is pure type machinery.

e2e: test/integration/test/authoring/paradedb-bm25-narrowing.test.ts
exercises the real paradedbPack and asserts six cases via vitest +
@ts-expect-error: well-formed bm25 typechecks; unknown options key
rejects; missing key_field rejects; unregistered type rejects; options
without type rejects; bare model() degraded path still accepts (no
narrowing).

Adds extension-paradedb to integration-tests deps.

Adds parseObjectLiteralStringMap to psl-attribute-parsing — parses
brace-balanced { key: "value", ... } argument values into
Record<string, string>. Bare-identifier keys, quoted-string-literal
values; boolean / number / nested-object leaves are rejected with a
clear diagnostic (V1 is string-leaves-only per the spec).

The PSL grammar itself needs no change: splitTopLevelSegments is
already brace-aware, so the existing parser preserves the raw
{...} value through to the interpreter.

The @@index interpreter now extracts the type and options named
arguments alongside the existing @Map handling. Validates that
options requires a surrounding type, that type is a quoted string
literal, and lowers everything into IndexNode.type / IndexNode.options.

Tests cover: documented example shape, multi-key options, boolean
leaf rejection, number leaf rejection, options-without-type, malformed
object literal, and the unchanged "no type or options" path.

…pack

Adds an integration test that exercises the full PSL -> IR -> registry
validation path with the real paradedbPack:

1. The documented spec example (@@index([body], type: "bm25",
   options: { key_field: "id" }, map: "doc_body_bm25_idx")) lowers
   to a Contract IR index node carrying type, options, and name.
2. The lowered contract validates clean against a registry built from
   paradedbIndexTypes.entries.
3. A PSL-authored bm25 index whose options miss the required key_field
   is rejected by the registry with a clear error.

This complements the unit tests in contract-psl by going through the
actual pack metadata and validateContract path.

…exIR

The Postgres introspection query joins pg_am and reads
pg_class.reloptions so introspected SqlIndexIR now carries:
- type: the index method (dropped to undefined when amname is "btree",
  since that is the Postgres default and a contract index without an
  explicit type should match a default-method introspected index)
- options: pg_class.reloptions parsed from {key=value, ...} into
  Record<string, string> (Postgres returns reloption values as raw
  text regardless of the underlying scalar type)

The family verifier's indexExtrasMatch now compares contract options
to introspected options via String() coercion so a contract
`fillfactor: 70` matches an introspected `fillfactor: "70"` without
forcing a spurious DROP+CREATE.

Without this wiring the migration planner would treat any contract
index with type set as different from any introspected index on the
same columns — forcing DROP+CREATE on every plan even when the live
index already matches the contract.

Tests: four PGlite integration cases covering the matrix — default
btree (type/options unset), non-default gin (type set, options unset),
default btree with WITH options (type unset, options set), and gin
with WITH options (both set).

…clause

Hoist extras?.options into a local so the WITH-clause check uses
optional chaining instead of !-assertions, which biome rejects under
lint/style/noNonNullAssertion.

…x_mismatch planner branch

The issue-planner index_mismatch branch reconstructed the contract index
from issue.expected (column names only), so adding a typed index to an
existing table emitted CREATE INDEX without USING/WITH and rebuilt as a
default btree. Look up the contract index by columns and pass type,
options, and an explicit name through to CreateIndexCall.

…uild registry from packs in family validateContract

The internal validateSqlStorage previously short-circuited the type lookup
when no registry was supplied, and the SQL family runtime never passed
one. Net result: the CLI validateContract codepath silently accepted any
index type literal, defeating the design-time gate the registry is meant
to be (per ADR 210).

- Internal validateSqlStorage now takes a non-undefined IndexTypeRegistry.
- Public validateContract defaults a missing options.indexTypeRegistry to
  an empty registry, so unregistered type literals fail validation
  regardless of caller setup.
- createSqlFamilyInstance walks [adapter, target, ...extensions] for
  indexTypes entries via buildIndexTypeRegistry(), caches the registry
  once per family instance, and passes it to all four sqlValidateContract
  call sites (validateContract, verify, schemaVerify, sign).

…rant-opt-in, not framework-enforced

The previous wording implied validateSqlStorage validates options "in
strict mode", which read as a framework guarantee. arktype is
loose-by-default and the framework merely invokes whatever validator the
registrant constructed; strictness is a property of that validator. Make
the recommendation explicit without claiming the framework imposes it.

Two gaps in the PSL integration coverage for the index-type registry:
unregistered type (TS DSL covered both compile-time and runtime, PSL
only covered compile-time via parser; runtime side untested) and an
empty options literal (parser produces {}; pipeline through to the
validator was unasserted). Both authored as @@index attributes, lowered
through the real paradedb pack, and asserted at the runtime registry
boundary.

…== undefined

The contract-dsl `index()` factory and the emitter index serialization
used truthy checks for `name`, `type`, and `options`, while the rest of
the framework (validate.ts, verify-helpers.ts, op-factory-call.ts,
issue-planner.ts) reads these fields with `=== undefined`. Align both
authoring sites on the framework convention.

…pes to Record<never, never>

The bare model() import previously defaulted IndexTypes to a wildcard
(Record<string, { options: Record<string, unknown> }>), so any string
literal typechecked at constraints.index({ type, options }) — even when
no packs were attached and no index types were registered. Drop the
wildcard. With no attached packs, only the default-index form
constraints.index(cols.x) (no type/options) typechecks; type literals
are restricted to whatever attached packs registered.

The IndexInput discriminated union already had the right structure for
the empty case (keyof IndexTypes extends never → ConstraintOptions<Name>);
the wildcard was the inconsistency.

Three lowering/runtime tests authored typed indexes via the bare model()
to exercise IR pass-through. They now use createComposedAuthoringHelpers
with a small test pack (test/helpers/test-index-pack.ts) that registers
bm25 and hash with permissive option shapes. The paradedb narrowing test
flips: bare model() now @ts-expect-errors on type: "made-up" and accepts
the no-options default-index form.

contract-builder.normalization.test.ts: simplified the "extension index
config with expression fields" test to a single pass-through case using
the real { key_field: "id" } shape; the old nested-array fields[]
payload was a leftover from the deleted bm25Index() helper.

…ten bare index overloads

Three small cleanups enabled by the wildcard removal:

- composed-authoring-helpers.ts dropped its local copies of
  ExtractIndexTypesFromPack, AllPackIndexTypeLiterals, and
  MergedPackIndexTypes. They were near-duplicates of the canonical
  versions in contract-types.ts. MergeAllPackIndexTypes now reuses
  MergeExtensionIndexTypes directly.

- contract-types.ts MergeExtensionIndexTypes now clamps the value side
  with Extract<..., { readonly options: unknown }>. The clamp tells the
  type-checker the resulting map structurally extends IndexTypeMap, so
  MergeAllPackIndexTypes no longer needs the extends infer M extends
  IndexTypeMap ? M : Record<never, never> coercion at use sites.

- contract-dsl.ts bare index() overloads use ConstraintOptions<Name>
  directly instead of IndexInput<Name, Record<never, never>>. With no
  packs attached IndexInput already evaluates to ConstraintOptions, so
  using it directly is self-documenting.

…es IndexTypeRegistration directly

The previous design carried two parallel artifacts on every pack: the
runtime indexTypes entries array and a __indexTypes phantom typed map.
Both had to be kept in sync by hand, with no compile-time link between
them — adding .add(...) to the builder would update one and silently
leave the other behind.

Introduce a read-only IndexTypeRegistration<TMap> interface that exposes
just entries (runtime) and IndexTypes (phantom). IndexTypeBuilder
extends it. The pack stores the builder verbatim in its indexTypes
field; both halves flow from a single source of truth, and the
read-only interface prevents the pack from being misused as a mutable
registry.

Consumer-side adjustments:
- ExtractIndexTypesFromPack<P> reads P[indexTypes] typed as
  IndexTypeRegistration<infer M>.
- buildIndexTypeRegistry iterates descriptor.indexTypes.entries.
- __indexTypes? dropped from SqlContractResult (only tests read it;
  narrowing is verified end-to-end via paradedb-bm25-narrowing).
- ParadeDB descriptor-meta.ts collapsed from base+intersection to a
  plain as const literal.
- contract-builder.index-types.test.ts updated; the two
  SqlContractResult.__indexTypes tests removed (redundant with upstream
  MergeExtensionIndexTypes tests).

ADR 210 §3 and the matching/lookup/dispatch prose updated to drop the
"phantom-typed __indexTypes field" framing in favor of "single
registration value carrying both halves".

…Types; remove buildSqlSpec cast

The cast at buildSqlSpec(createSqlConstraintsDsl() as unknown as
SqlContext<Fields, IndexTypes>[constraints]) was bridging from a bare
DSL value to one with pack-aware narrowing. Both are the same runtime
function; only the type-level signature differs.

Make createConstraintsDsl and createSqlConstraintsDsl generic over
IndexTypes, with the inner index overloads using IndexInput<Name,
IndexTypes> directly. buildSqlSpec passes its IndexTypes generic to
createSqlConstraintsDsl<IndexTypes>(); no cast needed.

The implementation signatures inner options field was loosened from
Record<string, unknown> to unknown, because per-pack option shapes
(like { key_field: string }) are closed object types that arent
strictly assignable to Record<string, unknown>. A single property-
scoped as Record<string, unknown> cast at the spread point stores the
value into the IR.

Net: one as unknown as cast removed, one minimal as cast introduced at
the storage boundary.

…p dead branches

F08: paradedb-bm25-narrowing.test.ts gains two positive expectTypeOf
assertions on Doc.__indexTypes — bare model() resolves to Record<never,
never>, helpers-bound model() (with paradedb attached) carries the bm25
shape. The boundary is now locked at the type level rather than relying
on absence of TS errors.

F10: psl-index-type-options.integration.test.ts "rejects bm25 with bad
options" case tightened from .toThrow(/key_field|bm25/) to instanceof
ContractValidationError plus message-contains-both bm25 AND key_field.
Either-word match was loose enough to pass on incidental wording.

F14: dropped the hasExtras ternary in CreateIndexCall.toOp and the
two issue-planner.ts branches (missing_table, index_mismatch). Calling
createIndex(..., extras) with an empty extras object behaves the same
as omitting the arg, so the conditional was dead. Postgres tests still
155/155.

…r-property error positions

Collapsing constraints.index to a single multi-field overload makes
TypeScript pin error positions to the offending property (an unknown
options key, a wrong type literal, missing required option fields)
instead of reporting a generic "no overload matches this call" at the
call expression. The trade-off: callers always pass the field list as
an array, even for single-column indexes:

  constraints.index(cols.body, ...)    // before
  constraints.index([cols.body], ...)  // after

Migrated all in-repo callers (tests, integration test fixtures, CLI
test fixtures, e2e migrations) in lockstep. The paradedb narrowing test
now lands @ts-expect-error directives on the offending property line
inside the options literal, matching the new TS error positions.

Also fixed obsolete MySQL/MariaDB/MSSQL adapter mentions in ADR 210
and the PR description; only postgres and sqlite SQL adapters exist.

…owering, not at runtime

Index-type validation now runs inside buildSqlContractFromDefinition,
the shared lowering both TS (defineContract) and PSL
(interpretPslDocumentToSqlContract) authoring funnel through. Bad
types or option shapes throw at authoring time.

- packages/2-sql/1-core/contract/src/validators.ts: validateIndexTypes
  lives here next to validateStorageSemantics. Both validate the
  storage IR; build-contract.ts assertStorageSemantics calls them in
  one step.
- packages/2-sql/1-core/contract/src/validate.ts: drop validateIndexTypes
  (moved to validators.ts) and the indexTypeRegistry option from the
  public validateContract API. Runtime keeps structural / referential /
  semantic checks; no registry needed.
- packages/2-sql/2-authoring/contract-ts/src/build-contract.ts: build a
  per-contract IndexTypeRegistry from definition.target +
  definition.extensionPacks inline in assertStorageSemantics.
- packages/2-sql/9-family/src/core/control-instance.ts: strip the family
  registry build, the DescriptorWithIndexTypes interface, and the
  { indexTypeRegistry } argument at all four sqlValidateContract call
  sites.

Tests:
- validate.test.ts cases call validateIndexTypes directly from
  validators.ts.
- contract-builder.constraints.test.ts asserts defineContract throws
  at authoring time on an unregistered type.
- contract-psl/test/interpreter.test.ts attaches a permissive bm25
  test pack so the existing PSL parser tests can lower successfully.
- paradedb-bm25-narrowing.test.ts wraps the @ts-expect-error cases in
  expect(...).toThrow(...) since defineContract now throws synchronously.
- psl-index-type-options.integration.test.ts: rewrite negative cases
  to assert interpret() throws directly (validation happens inside
  the interpreter, not in a separate validateContract call).

Docs:
- ADR 210 §4 retitled "Validation seam at the ContractIR -> Contract
  boundary" and rewritten around the new seam.
- PR description: "Authoring-time validator" bullet replaces the old
  "Validator hook" + "Family runtime wiring" pair.