@devp0nt/route0 1.0.0-next.67 → 1.0.0-next.68

package/src/index.test.ts

@@ -5,40 +5,21 @@ import type {
   AnyRoute,
   AnyRouteOrDefinition,
   CallableRoute,
-  CanInputBeEmpty,
+  IsParamsOptional,
   ExactLocation,
   Extended,
   ExtractRoute,
   ExtractRoutesKeys,
-  HasLooseSearch,
-  HasNamedSearch,
   HasParams,
-  HasSearch,
   IsAncestor,
   IsDescendant,
   IsSame,
   IsSameParams,
   KnownLocation,
-  LooseFlatInput,
-  LooseFlatInputStringOnly,
-  LooseFlatInputWithHash,
-  LooseFlatOutput,
-  LooseFlatOutputWithHash,
-  LooseSearchInput,
-  LooseSearchInputStringOnly,
-  LooseSearchOutput,
   ParamsInput,
   ParamsInputStringOnly,
   ParamsOutput,
   RoutesPretty,
-  StrictFlatInput,
-  StrictFlatInputStringOnly,
-  StrictFlatInputWithHash,
-  StrictFlatOutput,
-  StrictFlatOutputWithHash,
-  StrictSearchInput,
-  StrictSearchInputStringOnly,
-  StrictSearchOutput,
   UnknownLocation,
   WeakAncestorLocation,
   WeakDescendantLocation,
@@ -49,124 +30,212 @@ describe('Route0', () => {
   it('simple', () => {
     const route0 = Route0.create('/')
     const path = route0.get()
-    const pathHash = route0.get({ hash: 'zxc' })
+    const pathHash = route0.get({ '#': 'zxc' })
     expect(route0).toBeInstanceOf(Route0)
-    // expectTypeOf<typeof path>().toEqualTypeOf<'/'>()
     expect(path).toBe('/')
     expectTypeOf<HasParams<typeof route0>>().toEqualTypeOf<false>()
-    expect(path).toBe(route0.flat())
     expect(pathHash).toBe('/#zxc')
-    expect(pathHash).toBe(route0.flat({ hash: 'zxc' }))
   })
 
   it('simple, callable', () => {
     const route0 = Route0.create('/')
     const path = route0()
-    const pathHash = route0({ hash: 'zxc' })
+    const pathHash = route0({ '#': 'zxc' })
     expect(route0).toBeInstanceOf(Route0)
-    // expectTypeOf<typeof path>().toEqualTypeOf<'/'>()
     expect(path).toBe('/')
-    expect(path).toBe(route0.flat())
     expect(pathHash).toBe('/#zxc')
-    expect(pathHash).toBe(route0.flat({ hash: 'zxc' }))
   })
 
-  it('simple any search', () => {
+  it('search', () => {
     const route0 = Route0.create('/')
-    const path = route0.get({ search: { q: '1' } })
-    const pathHash = route0.get({ search: { q: '1' }, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/?${string}`>()
+    const path = route0.get({ '?': { q: '1' } })
+    const pathHash = route0.get({ '?': { q: '1' }, '#': 'zxc' })
     expect(path).toBe('/?q=1')
-    expect(path).toBe(route0.flat({ q: '1' }, false, true))
-    expect(path).toBe(route0.flatLoose({ q: '1' }))
     expect(pathHash).toBe('/?q=1#zxc')
-    expect(pathHash).toBe(route0.flat({ q: '1', hash: 'zxc' }, false, true))
-    expect(pathHash).toBe(route0.flatLoose({ q: '1', hash: 'zxc' }))
-
-    const route1 = Route0.create('/&')
-    expect(path).toBe(route1.flat({ q: '1' }))
-    expect(pathHash).toBe(route1.flat({ q: '1', hash: 'zxc' }))
+    expect(route0({ '?': { q: '1' } })).toBe(path)
+    expect(route0({ '?': { q: '1' }, '#': 'zxc' })).toBe(pathHash)
+    expectTypeOf<(typeof route0)['Infer']['SearchInput']>().toEqualTypeOf<Record<string, unknown>>()
+  })
+
+  it('typed search input', () => {
+    const route0 = Route0.create('/').search<{ q: string }>()
+    const path = route0.get({ '?': { q: '1' } })
+    const pathHash = route0.get({ '?': { q: '1' }, '#': 'zxc' })
+    const pathNoQuery = route0.get({ '#': 'zxc' })
+    // @ts-expect-error invalid search param type
+    const pathInvalidQueryType = route0.get({ '?': { q: 1 } })
+    // @ts-expect-error invalid search param key
+    const pathInvalidQueryKey = route0.get({ '?': { x: '1' } })
+    expect(path).toBe('/?q=1')
+    expect(pathHash).toBe('/?q=1#zxc')
+    expect(pathNoQuery).toBe('/#zxc')
+    expect(pathInvalidQueryType).toBe('/?q=1')
+    expect(pathInvalidQueryKey).toBe('/?x=1')
+    expectTypeOf<(typeof route0)['Infer']['SearchInput']>().toEqualTypeOf<{ q: string }>()
+    expect(route0({ '?': { q: '1' } })).toBe(path)
+    expect(route0({ '?': { q: '1' }, '#': 'zxc' })).toBe(pathHash)
+    expect(route0({ '#': 'zxc' })).toBe(pathNoQuery)
+    // @ts-expect-error invalid search param type
+    expect(route0({ '?': { q: 1 } })).toBe(pathInvalidQueryType)
+    // @ts-expect-error invalid search param key
+    expect(route0({ '?': { x: '1' } })).toBe(pathInvalidQueryKey)
   })
 
   it('params', () => {
     const route0 = Route0.create('/prefix/:x/some/:y/:z')
     const path = route0.get({ x: '1', y: 2, z: '3' })
-    const pathHash = route0.get({ x: '1', y: 2, z: '3', hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/some/${string}/${string}`>()
+    const pathHash = route0.get({ x: '1', y: 2, z: '3', '#': 'zxc' })
     expect(path).toBe('/prefix/1/some/2/3')
     expectTypeOf<HasParams<typeof route0>>().toEqualTypeOf<true>()
-    expect(path).toBe(route0.flat({ x: '1', y: 2, z: '3' }))
     expect(pathHash).toBe('/prefix/1/some/2/3#zxc')
-    expect(pathHash).toBe(route0.flat({ x: '1', y: 2, z: '3', hash: 'zxc' }))
+    expectTypeOf<(typeof route0)['Infer']['ParamsInput']>().toEqualTypeOf<{
+      x: string | number
+      y: string | number
+      z: string | number
+    }>()
+    expectTypeOf<(typeof route0)['Infer']['ParamsOutput']>().toEqualTypeOf<{ x: string; y: string; z: string }>()
+    expect(route0({ x: '1', y: 2, z: '3' })).toBe(path)
+    expect(route0({ x: '1', y: 2, z: '3', '#': 'zxc' })).toBe(pathHash)
   })
 
-  it('params and any search', () => {
+  it('params and search', () => {
     const route0 = Route0.create('/prefix/:x/some/:y/:z')
-    const path = route0.get({ x: '1', y: 2, z: '3', search: { q: '1' } })
-    const pathHash = route0.get({ x: '1', y: 2, z: '3', search: { q: '1' }, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/some/${string}/${string}?${string}`>()
+    const path = route0.get({ x: '1', y: 2, z: '3', '?': { q: '1' } })
+    const pathHash = route0.get({ x: '1', y: 2, z: '3', '?': { q: '1' }, '#': 'zxc' })
     expect(path).toBe('/prefix/1/some/2/3?q=1')
-    expect(path).toBe(route0.flat({ x: '1', y: 2, z: '3', q: '1' }, false, true))
     expect(pathHash).toBe('/prefix/1/some/2/3?q=1#zxc')
-    expect(pathHash).toBe(route0.flat({ x: '1', y: 2, z: '3', q: '1', hash: 'zxc' }, false, true))
-    const route1 = Route0.create('/prefix/:x/some/:y/:z&')
-    expect(path).toBe(route1.flat({ x: '1', y: 2, z: '3', q: '1' }))
-    expect(pathHash).toBe(route1.flat({ x: '1', y: 2, z: '3', q: '1', hash: 'zxc' }))
+    expect(route0({ x: '1', y: 2, z: '3', '?': { q: '1' } })).toBe(path)
+    expect(route0({ x: '1', y: 2, z: '3', '?': { q: '1' }, '#': 'zxc' })).toBe(pathHash)
+  })
+
+  it('optional named params', () => {
+    const route0 = Route0.create('/prefix/:x?/:y')
+    expect(route0.get({ y: '2' })).toBe('/prefix/2')
+    expect(route0.get({ x: '1', y: '2' })).toBe('/prefix/1/2')
+    expectTypeOf<(typeof route0)['Infer']['ParamsDefinition']>().toEqualTypeOf<{ x: false; y: true }>()
+    expectTypeOf<(typeof route0)['Infer']['ParamsInput']>().toEqualTypeOf<{
+      y: string | number
+      x?: string | number | undefined
+    }>()
+    expectTypeOf<(typeof route0)['Infer']['ParamsOutput']>().toEqualTypeOf<{
+      y: string
+      x: string | undefined
+    }>()
   })
 
-  it('search', () => {
-    const route0 = Route0.create('/prefix&y&z')
-    expectTypeOf<(typeof route0)['searchDefinition']>().toEqualTypeOf<{ y: true; z: true }>()
-    const path = route0.get({ search: { y: '1', z: '2' } })
-    const pathHash = route0.get({ search: { y: '1', z: '2' }, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix?${string}`>()
-    expect(path).toBe('/prefix?y=1&z=2')
-    expect(path).toBe(route0.flat({ y: '1', z: '2' }))
-    expect(pathHash).toBe('/prefix?y=1&z=2#zxc')
-    expect(pathHash).toBe(route0.flat({ y: '1', z: '2', hash: 'zxc' }))
+  it('wildcards and optional wildcards', () => {
+    const routeWildcard = Route0.create('/app*')
+    const routeOptionalWildcard = Route0.create('/orders/*?')
+    expect(routeWildcard.get({ '*': '' })).toBe('/app')
+    expect(routeWildcard.get({ '*': '/home' })).toBe('/app/home')
+    expect(routeWildcard.get({ '*': '-1' })).toBe('/app-1')
+    expect(routeWildcard.getLocation('/app').exact).toBe(true)
+    expect(routeWildcard.getLocation('/app/home').exact).toBe(true)
+    expect(routeOptionalWildcard.get()).toBe('/orders')
+    expect(routeOptionalWildcard.get({ '*': 'completed/list' })).toBe('/orders/completed/list')
+    expect(routeOptionalWildcard.getLocation('/orders').exact).toBe(true)
+    expect(routeOptionalWildcard.getLocation('/orders/').exact).toBe(true)
+    expect(routeOptionalWildcard.getLocation('/orders/completed/list').exact).toBe(true)
+    expectTypeOf<(typeof routeWildcard)['Infer']['ParamsDefinition']>().toEqualTypeOf<{ '*': true }>()
+    expectTypeOf<(typeof routeOptionalWildcard)['Infer']['ParamsDefinition']>().toEqualTypeOf<{ '*': false }>()
+    expectTypeOf<(typeof routeWildcard)['Infer']['ParamsOutput']>().toEqualTypeOf<{ '*': string }>()
+    expectTypeOf<(typeof routeOptionalWildcard)['Infer']['ParamsOutput']>().toEqualTypeOf<{ '*': string | undefined }>()
+  })
+
+  it('difference: /path/x* vs /path/x/* matching', () => {
+    const inlineWildcard = Route0.create('/path/x*')
+    const segmentWildcard = Route0.create('/path/x/*')
+
+    // /path/x*:
+    // - matches '/path/x'
+    // - matches '/path/x123' (same segment continuation)
+    // - matches '/path/x/123' (slash continuation)
+    expect(inlineWildcard.getLocation('/path/x').exact).toBe(true)
+    expect(inlineWildcard.getLocation('/path/x123').exact).toBe(true)
+    expect(inlineWildcard.getLocation('/path/x/123').exact).toBe(true)
+
+    // /path/x/*:
+    // - matches '/path/x' and '/path/x/...'
+    // - does NOT match '/path/x123' (because 'x' is a full segment here)
+    expect(segmentWildcard.getLocation('/path/x').exact).toBe(true)
+    expect(segmentWildcard.getLocation('/path/x/123').exact).toBe(true)
+    expect(segmentWildcard.getLocation('/path/x123').exact).toBe(false)
+  })
+
+  it('difference: /path/x* vs /path/x/* URL building', () => {
+    const inlineWildcard = Route0.create('/path/x*')
+    const segmentWildcard = Route0.create('/path/x/*')
+
+    // Inline wildcard appends directly to the "x" prefix.
+    expect(inlineWildcard.get({ '*': '123' })).toBe('/path/x123')
+    expect(inlineWildcard.get({ '*': '/123' })).toBe('/path/x/123')
+
+    // Segment wildcard appends as a new segment after '/path/x/'.
+    expect(segmentWildcard.get({ '*': '123' })).toBe('/path/x/123')
+    expect(segmentWildcard.get({ '*': '/123' })).toBe('/path/x/123')
+  })
+
+  it('mixed required and optional named params combinations', () => {
+    const route = Route0.create('/org/:orgId/user/:userId?/:tab')
+    expect(route.get({ orgId: 'acme', tab: 'settings' })).toBe('/org/acme/user/settings')
+    expect(route.get({ orgId: 'acme', userId: '42', tab: 'settings' })).toBe('/org/acme/user/42/settings')
+
+    const locNoOptional = route.getLocation('/org/acme/user/settings')
+    expect(locNoOptional.exact).toBe(true)
+    if (locNoOptional.exact) {
+      expect(locNoOptional.params).toMatchObject({
+        orgId: 'acme',
+        userId: undefined,
+        tab: 'settings',
+      })
+    }
+
+    const locWithOptional = route.getLocation('/org/acme/user/42/settings')
+    expect(locWithOptional.exact).toBe(true)
+    if (locWithOptional.exact) {
+      expect(locWithOptional.params).toMatchObject({
+        orgId: 'acme',
+        userId: '42',
+        tab: 'settings',
+      })
+    }
   })
 
-  it('params and search', () => {
-    const route0 = Route0.create('/prefix/:x/some/:y/:z&z&c')
-    const path = route0.get({ x: '1', y: '2', z: '3', search: { z: '4', c: '5' } })
-    const pathHash = route0.get({ x: '1', y: '2', z: '3', search: { z: '4', c: '5' }, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/some/${string}/${string}?${string}`>()
-    expect(path).toBe('/prefix/1/some/2/3?z=4&c=5')
-    expect(pathHash).toBe('/prefix/1/some/2/3?z=4&c=5#zxc')
-    // very strange case
-    expect(route0.flat({ x: '1', y: '2', z: '4', c: '5' })).toBe('/prefix/1/some/2/4?z=4&c=5')
-    expect(route0.flat({ x: '1', y: '2', z: '4', c: '5', hash: 'zxc' })).toBe('/prefix/1/some/2/4?z=4&c=5#zxc')
-  })
-
-  it('params and search and any search', () => {
-    const route0 = Route0.create('/prefix/:x/some/:y/:z&z&c')
-    const path = route0.get({ x: '1', y: '2', z: '3', search: { z: '4', c: '5', o: '6' } })
-    const pathHash = route0.get({ x: '1', y: '2', z: '3', search: { z: '4', c: '5', o: '6' }, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/some/${string}/${string}?${string}`>()
-    expect(path).toBe('/prefix/1/some/2/3?z=4&c=5&o=6')
-    expect(pathHash).toBe('/prefix/1/some/2/3?z=4&c=5&o=6#zxc')
-    // very strange case
-    expect(route0.flat({ x: '1', y: '2', z: '4', c: '5', o: '6' }, false, true)).toBe('/prefix/1/some/2/4?z=4&c=5&o=6')
-    expect(route0.flat({ x: '1', y: '2', z: '4', c: '5', o: '6', hash: 'zxc' }, false, true)).toBe(
-      '/prefix/1/some/2/4?z=4&c=5&o=6#zxc',
-    )
-    const route1 = Route0.create('/prefix/:x/some/:y/:z&z&c&')
-    expect(route1.flat({ x: '1', y: '2', z: '4', c: '5', o: '6' })).toBe('/prefix/1/some/2/4?z=4&c=5&o=6')
-    expect(route1.flat({ x: '1', y: '2', z: '4', c: '5', o: '6', hash: 'zxc' })).toBe(
-      '/prefix/1/some/2/4?z=4&c=5&o=6#zxc',
-    )
+  it('optional wildcard before required static segment', () => {
+    const route = Route0.create('/orders/*?/details')
+    expect(route.get()).toBe('/orders/details')
+    expect(route.get({ '*': 'completed/list' })).toBe('/orders/completed/list/details')
+    expect(route.getLocation('/orders/details').exact).toBe(true)
+    expect(route.getLocation('/orders/completed/list/details').exact).toBe(true)
+  })
+
+  it('paramsSchema accepts optional-only and mixed params', () => {
+    const optionalOnly = Route0.create('/x/:id?')
+    expect(optionalOnly.paramsSchema.safeParse(undefined)).toMatchObject({
+      success: true,
+      data: { id: undefined },
+      error: undefined,
+    })
+
+    const mixed = Route0.create('/x/:id/:slug?')
+    expect(mixed.paramsSchema.safeParse({ id: '1' })).toMatchObject({
+      success: true,
+      data: { id: '1', slug: undefined },
+      error: undefined,
+    })
+    expect(mixed.paramsSchema.safeParse({ slug: 'x' }).success).toBe(false)
   })
 
   it('simple extend', () => {
     const route0 = Route0.create('/prefix')
     const route1 = route0.extend('/suffix')
     const path = route1.get()
-    const pathHash = route1.get({ hash: 'zxc' })
+    const pathHash = route1.get({ '#': 'zxc' })
     // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/suffix`>()
     expect(path).toBe('/prefix/suffix')
-    expect(path).toBe(route1.flat())
     expect(pathHash).toBe('/prefix/suffix#zxc')
-    expect(pathHash).toBe(route1.flat({ hash: 'zxc' }))
+    expect(route1()).toBe(path)
+    expect(route1({ '#': 'zxc' })).toBe(pathHash)
   })
 
   it('simple extend double slash', () => {
@@ -176,12 +245,10 @@ describe('Route0', () => {
     expect(route1.get()).toBe('/suffix1/')
     const route2 = route1.extend('/suffix2')
     const path = route2.get()
-    const pathHash = route2.get({ hash: 'zxc' })
+    const pathHash = route2.get({ '#': 'zxc' })
     // expectTypeOf<typeof path>().toEqualTypeOf<`/suffix1/suffix2`>()
     expect(path).toBe('/suffix1/suffix2')
-    expect(path).toBe(route2.flat())
     expect(pathHash).toBe('/suffix1/suffix2#zxc')
-    expect(pathHash).toBe(route2.flat({ hash: 'zxc' }))
   })
 
   it('simple extend no slash', () => {
@@ -189,12 +256,10 @@ describe('Route0', () => {
     const route1 = route0.extend('suffix1')
     const route2 = route1.extend('suffix2')
     const path = route2.get()
-    const pathHash = route2.get({ hash: 'zxc' })
+    const pathHash = route2.get({ '#': 'zxc' })
     // expectTypeOf<typeof path>().toEqualTypeOf<`/suffix1/suffix2`>()
     expect(path).toBe('/suffix1/suffix2')
-    expect(path).toBe(route2.flat())
     expect(pathHash).toBe('/suffix1/suffix2#zxc')
-    expect(pathHash).toBe(route2.flat({ hash: 'zxc' }))
   })
 
   it('simple extend no slash chaos', () => {
@@ -231,143 +296,124 @@ describe('Route0', () => {
     const route0 = Route0.create('/prefix/:x')
     const route1 = route0.extend('/suffix/:y')
     const path = route1.get({ x: '1', y: '2' })
-    const pathHash = route1.get({ x: '1', y: '2', hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/suffix/${string}`>()
+    const pathHash = route1.get({ x: '1', y: '2', '#': 'zxc' })
     expect(path).toBe('/prefix/1/suffix/2')
-    expect(path).toBe(route1.flat({ x: '1', y: '2' }))
     expect(pathHash).toBe('/prefix/1/suffix/2#zxc')
-    expect(pathHash).toBe(route1.flat({ x: '1', y: '2', hash: 'zxc' }))
   })
 
-  it('extend with search params', () => {
-    const route0 = Route0.create('/prefix&y&z')
-    const route1 = route0.extend('/suffix&z&c')
-    const path = route1.get({ search: { y: '2', c: '3', a: '4' } })
-    expectTypeOf<(typeof route1)['searchDefinition']>().toEqualTypeOf<{
-      z: true
-      c: true
+  it('extend with typed search', () => {
+    const route0 = Route0.create('/prefix').search<{ y: string; z: string }>()
+    const route1 = route0.extend('/suffix')
+    const path = route1.get({ '?': { y: '2', z: '3' } })
+    expectTypeOf<(typeof route1)['Infer']['SearchInput']>().toEqualTypeOf<{
+      z: string
+      y: string
     }>()
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/suffix?${string}`>()
-    expect(path).toBe('/prefix/suffix?y=2&c=3&a=4')
+    expect(path).toBe('/prefix/suffix?y=2&z=3')
     const path1 = route1.get()
-    const pathHash1 = route1.get({ hash: 'zxc' })
-    // expectTypeOf<typeof path1>().toEqualTypeOf<`/prefix/suffix`>()
+    const pathHash1 = route1.get({ '#': 'zxc' })
     expect(path1).toBe('/prefix/suffix')
-    expect(path1).toBe(route1.flat())
     expect(pathHash1).toBe('/prefix/suffix#zxc')
-    expect(pathHash1).toBe(route1.flat({ hash: 'zxc' }))
   })
 
-  it('extend with params and search', () => {
-    const route0 = Route0.create('/prefix/:id&y&z')
-    const route1 = route0.extend('/:sn/suffix&z&c')
-    const path = route1.get({ id: 'myid', sn: 'mysn', search: { y: '2', c: '3', a: '4' } })
-    expectTypeOf<(typeof route1)['searchDefinition']>().toEqualTypeOf<{
-      z: true
-      c: true
+  it('extend with params and typed search', () => {
+    const route0 = Route0.create('/prefix/:id').search<{ y: string; z: string }>()
+    const route1 = route0.extend('/:sn/suffix')
+    const path = route1.get({ id: 'myid', sn: 'mysn', '?': { y: '2', z: '3' } })
+    expectTypeOf<(typeof route1)['Infer']['SearchInput']>().toEqualTypeOf<{
+      z: string
+      y: string
     }>()
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/${string}/suffix?${string}`>()
-    expect(path).toBe('/prefix/myid/mysn/suffix?y=2&c=3&a=4')
+    expect(path).toBe('/prefix/myid/mysn/suffix?y=2&z=3')
     const path1 = route1.get({ id: 'myid', sn: 'mysn' })
-    const pathHash1 = route1.get({ id: 'myid', sn: 'mysn', hash: 'zxc' })
-    // expectTypeOf<typeof path1>().toEqualTypeOf<`/prefix/${string}/${string}/suffix`>()
+    const pathHash1 = route1.get({ id: 'myid', sn: 'mysn', '#': 'zxc' })
     expect(path1).toBe('/prefix/myid/mysn/suffix')
-    expect(path1).toBe(route1.flat({ id: 'myid', sn: 'mysn' }))
     expect(pathHash1).toBe('/prefix/myid/mysn/suffix#zxc')
-    expect(pathHash1).toBe(route1.flat({ id: 'myid', sn: 'mysn', hash: 'zxc' }))
   })
 
-  it('extend with params and search, callable', () => {
-    const route0 = Route0.create('/prefix/:id&y&z')
-    const route1 = route0.extend('/:sn/suffix&z&c')
-    const path = route1({ id: 'myid', sn: 'mysn', search: { y: '2', c: '3', a: '4' } })
-    expectTypeOf<(typeof route1)['searchDefinition']>().toEqualTypeOf<{
-      z: true
-      c: true
-    }>()
-    // expectTypeOf<typeof path>().toEqualTypeOf<`/prefix/${string}/${string}/suffix?${string}`>()
-    expect(path).toBe('/prefix/myid/mysn/suffix?y=2&c=3&a=4')
-    const path1 = route1({ id: 'myid', sn: 'mysn' })
-    // expectTypeOf<typeof path1>().toEqualTypeOf<`/prefix/${string}/${string}/suffix`>()
-    expect(path1).toBe('/prefix/myid/mysn/suffix')
-    expect(path1).toBe(route1.flat({ id: 'myid', sn: 'mysn' }))
-    const pathHash1 = route1({ id: 'myid', sn: 'mysn', hash: 'zxc' })
-    expect(pathHash1).toBe('/prefix/myid/mysn/suffix#zxc')
-    expect(pathHash1).toBe(route1.flat({ id: 'myid', sn: 'mysn', hash: 'zxc' }))
+  it('extend with params and typed search, callable', () => {
+    // const route0 = Route0.create('/prefix/:id&y&z')
+    // const route1 = route0.extend('/:sn/suffix&z&c')
+    // const path = route1({ id: 'myid', sn: 'mysn', '?': { y: '2', c: '3', a: '4' } })
+    // expectTypeOf<(typeof route1)['searchDefinition']>().toEqualTypeOf<{
+    //   z: true
+    //   c: true
+    // }>()
+    // expect(path).toBe('/prefix/myid/mysn/suffix?y=2&c=3&a=4')
+    // const path1 = route1({ id: 'myid', sn: 'mysn' })
+    // expect(path1).toBe('/prefix/myid/mysn/suffix')
+    // const pathHash1 = route1({ id: 'myid', sn: 'mysn', '#': 'zxc' })
+    // expect(pathHash1).toBe('/prefix/myid/mysn/suffix#zxc')
   })
 
   it('abs default throw if no window.location.origin', () => {
     const route0 = Route0.create('/path')
-    expect(() => route0.get({ abs: true })).toThrow()
+    expect(() => route0.get(undefined, true)).toThrow()
     // const route0 = Route0.create('/path')
     // const path = route0.get({ abs: true })
-    // const pathHash = route0.get({ abs: true, hash: 'zxc' })
+    // const pathHash = route0.get({ abs: true, '#': 'zxc' })
     // // expectTypeOf<typeof path>().toEqualTypeOf<`${string}/path`>()
     // expect(path).toBe('https://example.com/path')
     // expect(path).toBe(route0.flat({}, true))
     // expect(pathHash).toBe('https://example.com/path#zxc')
-    // expect(pathHash).toBe(route0.flat({ hash: 'zxc' }, true))
+    // expect(pathHash).toBe(route0.flat({ '#': 'zxc' }, true))
   })
 
   it('abs as string not throw if no window.location.origin', () => {
     const route0 = Route0.create('/path')
-    const path = route0.get({ abs: 'https://example.com' })
+    const path = route0.get('https://example.com')
     expect(path).toBe('https://example.com/path')
   })
 
   it('abs as string not throw if no window.location.origin and not used additional path', () => {
     const route0 = Route0.create('/path')
-    const path = route0.get({ abs: 'https://example.com/x' })
+    const path = route0.get('https://example.com/x')
     expect(path).toBe('https://example.com/path')
   })
 
   it('abs default set window.location.origin', () => {
     ;(globalThis as unknown as { location?: { origin?: string } }).location = { origin: 'https://example.com' }
     const route0 = Route0.create('/path')
-    const path = route0.get({ abs: true })
-    const pathHash = route0.get({ abs: true, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`${string}/path`>()
+    const path = route0.get(true)
+    const pathHash = route0.get({ '#': 'zxc' }, true)
     expect(path).toBe('https://example.com/path')
-    expect(path).toBe(route0.flat({}, true))
+    expect(path).toBe(route0.get({}, true))
     expect(pathHash).toBe('https://example.com/path#zxc')
-    expect(pathHash).toBe(route0.flat({ hash: 'zxc' }, true))
+    expect(pathHash).toBe(route0.get({ '#': 'zxc' }, true))
     delete (globalThis as unknown as { location?: { origin?: string } }).location?.origin
   })
 
   it('abs set', () => {
     const route0 = Route0.create('/path', { origin: 'https://x.com' })
-    const path = route0.get({ abs: true })
-    const pathHash = route0.get({ abs: true, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`${string}/path`>()
+    const path = route0.get(true)
+    const pathHash = route0.get({ '#': 'zxc' }, true)
     expect(path).toBe('https://x.com/path')
-    expect(path).toBe(route0.flat({}, true))
+    expect(path).toBe(route0.get({}, true))
     expect(pathHash).toBe('https://x.com/path#zxc')
-    expect(pathHash).toBe(route0.flat({ hash: 'zxc' }, true))
+    expect(pathHash).toBe(route0.get({ '#': 'zxc' }, true))
   })
 
   it('abs override', () => {
     const route0 = Route0.create('/path', { origin: 'https://x.com' })
     route0.origin = 'https://y.com'
-    const path = route0.get({ abs: true })
-    const pasthHash = route0.get({ abs: true, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`${string}/path`>()
+    const path = route0.get(true)
+    const pasthHash = route0.get({ '#': 'zxc' }, true)
     expect(path).toBe('https://y.com/path')
-    expect(path).toBe(route0.flat({}, true))
+    expect(path).toBe(route0.get({}, true))
     expect(pasthHash).toBe('https://y.com/path#zxc')
-    expect(pasthHash).toBe(route0.flat({ hash: 'zxc' }, true))
+    expect(pasthHash).toBe(route0.get({ '#': 'zxc' }, true))
   })
 
   it('abs override extend', () => {
     const route0 = Route0.create('/path', { origin: 'https://x.com' })
     route0.origin = 'https://y.com'
     const route1 = route0.extend('/suffix')
-    const path = route1.get({ abs: true })
-    const pathHash = route1.get({ abs: true, hash: 'zxc' })
-    // expectTypeOf<typeof path>().toEqualTypeOf<`${string}/path/suffix`>()
+    const path = route1.get(true)
+    const pathHash = route1.get({ '#': 'zxc' }, true)
     expect(path).toBe('https://y.com/path/suffix')
-    expect(path).toBe(route1.flat({}, true))
+    expect(path).toBe(route1.get({}, true))
     expect(pathHash).toBe('https://y.com/path/suffix#zxc')
-    expect(pathHash).toBe(route1.flat({ hash: 'zxc' }, true))
+    expect(pathHash).toBe(route1.get({ '#': 'zxc' }, true))
   })
 
   // it('abs override many', () => {
@@ -387,53 +433,40 @@ describe('Route0', () => {
     const rWith = Route0.create('/a/:id', { origin: 'https://example.com' })
     // @ts-expect-error missing required path params
     expect(rWith.get()).toBe('/a/undefined')
-    // @ts-expect-error missing required path params
-    expect(rWith.flat()).toBe('/a/undefined')
 
     // @ts-expect-error missing required path params
     expect(rWith.get({})).toBe('/a/undefined')
-    // @ts-expect-error missing required path params
-    expect(rWith.flat({})).toBe('/a/undefined')
-    // @ts-expect-error missing required path params (object form abs)
-    expect(rWith.get({ abs: true })).toBe('https://example.com/a/undefined')
     // @ts-expect-error missing required path params (object form abs)
-    expect(rWith.flat({}, true)).toBe('https://example.com/a/undefined')
+    expect(rWith.get(true)).toBe('https://example.com/a/undefined')
     // @ts-expect-error missing required path params (object form search)
-    expect(rWith.get({ search: { q: '1' } })).toBe('/a/undefined?q=1')
-    // @ts-expect-error missing required path params (object form search), and loose search not allowed
-    expect(rWith.flat({ q: '1' })).toBe('/a/undefined')
+    expect(rWith.get({ '?': { q: '1' } })).toBe('/a/undefined?q=1')
 
     // @ts-expect-error params can not be sent as object value it should be argument
     rWith.get({ params: { id: '1' } }) // not throw becouse this will not used
-    expect(rWith.flat({ id: '1' })).toBe('/a/1')
+    expect(rWith.get({ id: '1' })).toBe('/a/1')
 
     const rNo = Route0.create('/b')
     // @ts-expect-error no path params allowed for this route (shorthand)
     expect(rNo.get({ id: '1' })).toBe('/b')
-    // @ts-expect-error loose search not allowed
-    expect(rNo.flat({ id: '1' })).toBe('/b')
-    // @ts-expect-error loose search not allowed
-    expect(rNo.flatStrict({ id: '1' })).toBe('/b')
-    expect(rNo.flat({ id: '1' }, false, true)).toBe('/b?id=1')
-    expect(Route0.create('/b&').flat({ id: '1' })).toBe('/b?id=1')
-    expect(Route0.create('/b').flatLoose({ id: '1' })).toBe('/b?id=1')
   })
 
   it('really any route assignable to AnyRoute', () => {
     expectTypeOf<Route0<string>>().toExtend<AnyRoute>()
+    expectTypeOf<Route0<string, { x: string }>>().toExtend<AnyRoute>()
     expectTypeOf<Route0<string>>().toExtend<AnyRouteOrDefinition>()
+    expectTypeOf<Route0<string, { x: string }>>().toExtend<AnyRouteOrDefinition>()
     expectTypeOf<Route0<'/path'>>().toExtend<AnyRoute>()
-    expectTypeOf<Route0<'/path'>>().toExtend<AnyRouteOrDefinition>()
+    expectTypeOf<Route0<'/path', { x: string }>>().toExtend<AnyRouteOrDefinition>()
     expectTypeOf<Route0<'/path/:id'>>().toExtend<AnyRoute>()
-    expectTypeOf<Route0<'/path/:id'>>().toExtend<AnyRouteOrDefinition>()
-    expectTypeOf<Route0<'/path/:id&x'>>().toExtend<AnyRoute>()
+    expectTypeOf<Route0<'/path/:id', { x?: string }>>().toExtend<AnyRouteOrDefinition>()
     expectTypeOf<CallableRoute<'/path'>>().toExtend<AnyRouteOrDefinition>()
+    expectTypeOf<CallableRoute<'/path', { x: string }>>().toExtend<AnyRouteOrDefinition>()
     expectTypeOf<CallableRoute<'/path'>>().toExtend<AnyRoute>()
-    expectTypeOf<CallableRoute<'/path'>>().toExtend<AnyRouteOrDefinition>()
+    expectTypeOf<CallableRoute<'/path', { x: string }>>().toExtend<AnyRoute>()
     expectTypeOf<CallableRoute<'/path/:id'>>().toExtend<AnyRoute>()
+    expectTypeOf<CallableRoute<'/path/:id', { x?: string }>>().toExtend<AnyRoute>()
     expectTypeOf<CallableRoute<'/path/:id'>>().toExtend<AnyRouteOrDefinition>()
-    expectTypeOf<CallableRoute<'/path/:id&x'>>().toExtend<AnyRoute>()
-    expectTypeOf<CallableRoute<'/path/:id&x'>>().toExtend<AnyRouteOrDefinition>()
+    expectTypeOf<CallableRoute<'/path/:id', { x?: string }>>().toExtend<AnyRouteOrDefinition>()
     expectTypeOf<CallableRoute>().toExtend<AnyRoute>()
     expectTypeOf<CallableRoute>().toExtend<AnyRouteOrDefinition>()
 
@@ -446,6 +479,11 @@ describe('Route0', () => {
     expectTypeOf<typeof route2>().toExtend<AnyRoute>()
     expectTypeOf<typeof route2>().toExtend<AnyRouteOrDefinition>()
 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const route3 = route.extend('/path3').search<{ x: string }>()
+    expectTypeOf<typeof route3>().toExtend<AnyRoute>()
+    expectTypeOf<typeof route3>().toExtend<AnyRouteOrDefinition>()
+
     // Test that specific CallableRoute with literal path IS assignable to AnyRouteOrDefinition
     expectTypeOf<CallableRoute<'/ideas/best'>>().toExtend<AnyRouteOrDefinition>()
 
@@ -505,39 +543,6 @@ describe('type utilities', () => {
     expectTypeOf<HasParams<Route0<'/path/:id'>>>().toEqualTypeOf<true>()
   })
 
-  it('HasSearch', () => {
-    expectTypeOf<HasSearch<'/path'>>().toEqualTypeOf<false>()
-    expectTypeOf<HasSearch<'/path&x'>>().toEqualTypeOf<true>()
-    expectTypeOf<HasSearch<'/path&x&y'>>().toEqualTypeOf<true>()
-    expectTypeOf<HasSearch<'/path&'>>().toEqualTypeOf<true>()
-
-    expectTypeOf<HasSearch<Route0<'/path'>>>().toEqualTypeOf<false>()
-    expectTypeOf<HasSearch<Route0<'/path&x&y'>>>().toEqualTypeOf<true>()
-    expectTypeOf<HasSearch<Route0<'/path&'>>>().toEqualTypeOf<true>()
-  })
-
-  it('HasNamedSearch', () => {
-    expectTypeOf<HasNamedSearch<'/path'>>().toEqualTypeOf<false>()
-    expectTypeOf<HasNamedSearch<'/path&x'>>().toEqualTypeOf<true>()
-    expectTypeOf<HasNamedSearch<'/path&x&y'>>().toEqualTypeOf<true>()
-    expectTypeOf<HasNamedSearch<'/path&'>>().toEqualTypeOf<false>()
-
-    expectTypeOf<HasNamedSearch<Route0<'/path'>>>().toEqualTypeOf<false>()
-    expectTypeOf<HasNamedSearch<Route0<'/path&x&y'>>>().toEqualTypeOf<true>()
-    expectTypeOf<HasNamedSearch<Route0<'/path&'>>>().toEqualTypeOf<false>()
-  })
-
-  it('HasLooseSearch', () => {
-    expectTypeOf<HasLooseSearch<'/path'>>().toEqualTypeOf<false>()
-    expectTypeOf<HasLooseSearch<'/path&x'>>().toEqualTypeOf<false>()
-    expectTypeOf<HasLooseSearch<'/path&x&y'>>().toEqualTypeOf<false>()
-    expectTypeOf<HasLooseSearch<'/path&'>>().toEqualTypeOf<true>()
-
-    expectTypeOf<HasLooseSearch<Route0<'/path'>>>().toEqualTypeOf<false>()
-    expectTypeOf<HasLooseSearch<Route0<'/path&x&y'>>>().toEqualTypeOf<false>()
-    expectTypeOf<HasLooseSearch<Route0<'/path&'>>>().toEqualTypeOf<true>()
-  })
-
   it('ParamsInput', () => {
     expectTypeOf<ParamsInput<'/path'>>().toEqualTypeOf<Record<never, never>>()
     expectTypeOf<ParamsInput<'/path/:id'>>().toEqualTypeOf<{ id: string | number }>()
@@ -557,186 +562,6 @@ describe('type utilities', () => {
     expectTypeOf<ParamsOutput<typeof route>>().toEqualTypeOf<{ id: string; name: string }>()
   })
 
-  it('LooseSearchInput', () => {
-    type T1 = LooseSearchInput<'/path'>
-    expectTypeOf<T1>().toEqualTypeOf<Record<string, string | number>>()
-
-    type T2 = LooseSearchInput<'/path&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      Partial<{
-        x: string | number
-        y: string | number
-      }> &
-        Record<string, string | number>
-    >()
-  })
-
-  it('LooseSearchOutput', () => {
-    type T1 = LooseSearchOutput<'/path'>
-    expectTypeOf<T1>().toEqualTypeOf<{
-      [key: string]: string | undefined
-    }>()
-
-    type T2 = LooseSearchOutput<'/path&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<{
-      [key: string]: string | undefined
-      x?: string | undefined
-      y?: string | undefined
-    }>()
-  })
-
-  it('StrictSearchInput', () => {
-    type T1 = StrictSearchInput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string | number; y?: string | number }>()
-  })
-
-  it('StrictSearchOutput', () => {
-    type T1 = StrictSearchOutput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string | undefined; y?: string | undefined }>()
-  })
-
-  it('LooseFlatInput', () => {
-    type T1 = LooseFlatInput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<
-      Partial<{
-        x: string | number
-        y: string | number
-      }> &
-        Record<string, string | number>
-    >()
-
-    type T2 = LooseFlatInput<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      {
-        id: string | number
-      } & Partial<{
-        x: string | number
-        y: string | number
-      }> &
-        Record<string, string | number>
-    >()
-  })
-  it('StrictFlatInput', () => {
-    type T1 = StrictFlatInput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string | number; y?: string | number }>()
-    type T2 = StrictFlatInput<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      Partial<{
-        x: string | number
-        y: string | number
-      }> & {
-        id: string | number
-      }
-    >()
-  })
-
-  it('LooseFlatOutput', () => {
-    type T1 = LooseFlatOutput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{
-      [x: string]: string | undefined
-      x?: string | undefined
-      y?: string | undefined
-    }>()
-
-    type T2 = LooseFlatOutput<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      {
-        id: string
-      } & {
-        [x: string]: string | undefined
-        x?: string | undefined
-        y?: string | undefined
-      }
-    >()
-  })
-  it('StrictLooseFlatOutput', () => {
-    type T1 = StrictFlatOutput<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string | undefined; y?: string | undefined }>()
-    type T2 = StrictFlatOutput<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      { id: string } & Partial<{
-        x?: string | undefined
-        y?: string | undefined
-      }>
-    >()
-  })
-
-  it('LooseFlatInputWithHash', () => {
-    type T1 = LooseFlatInputWithHash<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<
-      { hash?: string | number } & Partial<{
-        x: string | number
-        y: string | number
-      }> &
-        Record<string, string | number>
-    >()
-
-    type T2 = LooseFlatInputWithHash<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      { hash?: string | number } & {
-        id: string | number
-      } & Partial<{
-          x: string | number
-          y: string | number
-        }> &
-        Record<string, string | number>
-    >()
-  })
-  it('StrictFlatInputWithHash', () => {
-    type T1 = StrictFlatInputWithHash<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ hash?: string | number } & { x?: string | number; y?: string | number }>()
-    type T2 = StrictFlatInputWithHash<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      { hash?: string | number } & Partial<{
-        x: string | number
-        y: string | number
-      }> & {
-          id: string | number
-        }
-    >()
-  })
-
-  it('LooseFlatOutputWithHash', () => {
-    type T1 = LooseFlatOutputWithHash<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<
-      {
-        [x: string]: string | undefined
-        x?: string | undefined
-        y?: string | undefined
-      } & {
-        hash?: string | undefined
-      }
-    >()
-
-    type T2 = LooseFlatOutputWithHash<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      {
-        id: string
-      } & {
-        [x: string]: string | undefined
-        x?: string | undefined
-        y?: string | undefined
-      } & {
-        hash?: string | undefined
-      }
-    >()
-  })
-  it('StrictFlatOutputWithHash', () => {
-    type T1 = StrictFlatOutputWithHash<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<
-      { x?: string | undefined; y?: string | undefined } & { hash?: string | undefined }
-    >()
-    type T2 = StrictFlatOutputWithHash<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      { id: string } & Partial<{
-        x?: string | undefined
-        y?: string | undefined
-      }> & {
-          hash?: string | undefined
-        }
-    >()
-  })
-
   it('ParamsInputStringOnly', () => {
     expectTypeOf<ParamsInputStringOnly<'/path'>>().toEqualTypeOf<Record<never, never>>()
     expectTypeOf<ParamsInputStringOnly<'/path/:id'>>().toEqualTypeOf<{ id: string }>()
@@ -747,69 +572,21 @@ describe('type utilities', () => {
     expectTypeOf<ParamsInputStringOnly<typeof route>>().toEqualTypeOf<{ id: string; name: string }>()
   })
 
-  it('LooseSearchInputStringOnly', () => {
-    type T1 = LooseSearchInputStringOnly<'/path'>
-    expectTypeOf<T1>().toEqualTypeOf<Record<string, string>>()
-
-    type T2 = LooseSearchInputStringOnly<'/path&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      Partial<{
-        x: string
-        y: string
-      }> &
-        Record<string, string>
-    >()
-  })
-
-  it('StrictSearchInputStringOnly', () => {
-    type T1 = StrictSearchInputStringOnly<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string; y?: string }>()
-  })
-
-  it('LooseFlatInputStringOnly', () => {
-    type T1 = LooseFlatInputStringOnly<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<
-      Partial<{
-        x: string
-        y: string
-      }> &
-        Record<string, string>
-    >()
-
-    type T2 = LooseFlatInputStringOnly<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      {
-        id: string
-      } & Partial<{
-        x: string
-        y: string
-      }> &
-        Record<string, string>
-    >()
-  })
-  it('StrictFlatInputStringOnly', () => {
-    type T1 = StrictFlatInputStringOnly<'/path&x&y'>
-    expectTypeOf<T1>().toEqualTypeOf<{ x?: string; y?: string }>()
-    type T2 = StrictFlatInputStringOnly<'/path/:id&x&y'>
-    expectTypeOf<T2>().toEqualTypeOf<
-      Partial<{
-        x: string
-        y: string
-      }> & {
-        id: string
-      }
-    >()
-  })
-
-  it('CanInputBeEmpty', () => {
-    type T1 = CanInputBeEmpty<'/path'>
+  it('IsParamsOptional', () => {
+    type T1 = IsParamsOptional<'/path'>
     expectTypeOf<T1>().toEqualTypeOf<true>()
-    type T2 = CanInputBeEmpty<'/path/:id'>
+    type T2 = IsParamsOptional<'/path/:id'>
     expectTypeOf<T2>().toEqualTypeOf<false>()
-    type T3 = CanInputBeEmpty<'/path&x&y'>
+    type T3 = IsParamsOptional<'/path'>
     expectTypeOf<T3>().toEqualTypeOf<true>()
-    type T4 = CanInputBeEmpty<'/path/:id&x&y'>
+    type T4 = IsParamsOptional<'/path/:id'>
     expectTypeOf<T4>().toEqualTypeOf<false>()
+    type T5 = IsParamsOptional<'/path/:id?'>
+    expectTypeOf<T5>().toEqualTypeOf<true>()
+    type T6 = IsParamsOptional<'/path*'>
+    expectTypeOf<T6>().toEqualTypeOf<false>()
+    type T7 = IsParamsOptional<'/path*?'>
+    expectTypeOf<T7>().toEqualTypeOf<true>()
   })
 
   it('IsAncestor', () => {
@@ -857,9 +634,13 @@ describe('type utilities', () => {
   it('Extended', () => {
     expectTypeOf<Extended<'/path', '/child'>>().toEqualTypeOf<Route0<'/path/child'>>()
     expectTypeOf<Extended<'/path', '/:id'>>().toEqualTypeOf<Route0<'/path/:id'>>()
-    expectTypeOf<Extended<'/path', '&x&y'>>().toEqualTypeOf<Route0<'/path&x&y'>>()
-    expectTypeOf<Extended<'/path/:id', '/child&x'>>().toEqualTypeOf<Route0<'/path/:id/child&x'>>()
-    expectTypeOf<Extended<undefined, '/path'>>().toEqualTypeOf<Route0<'/path'>>()
+    expectTypeOf<Extended<'/path', '', { x: string; y: string }>>().toEqualTypeOf<
+      Route0<'/path', { x: string; y: string }>
+    >()
+    expectTypeOf<Extended<'/path/:id', '/child', { x: string }>>().toEqualTypeOf<
+      Route0<'/path/:id/child', { x: string }>
+    >()
+    expectTypeOf<Extended<undefined, '/path', { x: string }>>().toEqualTypeOf<Route0<'/path', { x: string }>>()
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const ancestor = Route0.create('/path')
@@ -1181,7 +962,7 @@ describe('getLocation', () => {
 
     it('with search params', () => {
       const routes = Routes.create({
-        search: '/search&q&filter',
+        search: '/search',
         users: '/users',
       })
 
@@ -1265,7 +1046,7 @@ describe('getLocation', () => {
         api,
         users: api.extend('/users'),
         userDetail: api.extend('/users/:id'),
-        userPosts: api.extend('/users/:id/posts&sort&filter'),
+        userPosts: api.extend('/users/:id/posts').search<{ sort: string; filter: string }>(),
       })
 
       const loc = routes._.getLocation('/api/v1/users/42/posts?sort=date&filter=published&extra=value')
@@ -1281,6 +1062,87 @@ describe('getLocation', () => {
       }
     })
 
+    it('resolves overlaps: static > required param > optional > wildcard', () => {
+      const routes = Routes.create({
+        usersStatic: '/users/new',
+        usersRequired: '/users/:id',
+        usersOptional: '/users/:id?',
+        usersWildcard: '/users/*?',
+      })
+
+      const locStatic = routes._.getLocation('/users/new')
+      expect(locStatic.exact).toBe(true)
+      if (locStatic.exact) {
+        expect(locStatic.route).toBe('/users/new')
+      }
+
+      const locRequired = routes._.getLocation('/users/123')
+      expect(locRequired.exact).toBe(true)
+      if (locRequired.exact) {
+        expect(locRequired.route).toBe('/users/:id')
+        expect(locRequired.params).toMatchObject({ id: '123' })
+      }
+
+      const locOptional = routes._.getLocation('/users')
+      expect(locOptional.exact).toBe(true)
+      if (locOptional.exact) {
+        expect(locOptional.route).toBe('/users/:id?')
+      }
+
+      const locWildcard = routes._.getLocation('/users/a/b/c')
+      expect(locWildcard.exact).toBe(true)
+      if (locWildcard.exact) {
+        expect(locWildcard.route).toBe('/users/*?')
+      }
+    })
+
+    it('resolves app wildcard compatibility cases like wouter', () => {
+      const routes = Routes.create({
+        appRoot: '/app',
+        appHome: '/app/home',
+        appId: '/app/:id',
+        appSplat: '/app*',
+      })
+
+      const m1 = routes._.getLocation('/app')
+      expect(m1.exact).toBe(true)
+      if (m1.exact) expect(m1.route).toBe('/app')
+
+      const m2 = routes._.getLocation('/app/home')
+      expect(m2.exact).toBe(true)
+      if (m2.exact) expect(m2.route).toBe('/app/home')
+
+      const m3 = routes._.getLocation('/app/123')
+      expect(m3.exact).toBe(true)
+      if (m3.exact) expect(m3.route).toBe('/app/:id')
+
+      const m4 = routes._.getLocation('/app-1')
+      expect(m4.exact).toBe(true)
+      if (m4.exact) expect(m4.route).toBe('/app*')
+    })
+
+    it('resolves /path/x* and /path/x/* differently in Routes', () => {
+      const routes = Routes.create({
+        inlineWildcard: '/path/x*',
+        segmentWildcard: '/path/x/*',
+      })
+
+      // '/path/x123' only matches inline wildcard.
+      const a = routes._.getLocation('/path/x123')
+      expect(a.exact).toBe(true)
+      if (a.exact) expect(a.route).toBe('/path/x*')
+
+      // '/path/x/123' matches both, but '/path/x/*' should win as more specific.
+      const b = routes._.getLocation('/path/x/123')
+      expect(b.exact).toBe(true)
+      if (b.exact) expect(b.route).toBe('/path/x/*')
+
+      // '/path/x' also matches both; segment wildcard remains preferred.
+      const c = routes._.getLocation('/path/x')
+      expect(c.exact).toBe(true)
+      if (c.exact) expect(c.route).toBe('/path/x/*')
+    })
+
     it('get location for extedned routes', () => {
       const a = Route0.create('/')
       const b = a.extend('/b')
@@ -1311,61 +1173,10 @@ describe('getLocation', () => {
   })
 })
 
-describe('input schemas', () => {
-  it('flatInputSchema validate (auto loose route)', () => {
-    const route = Route0.create('/:id&a&')
-    const result = route.flatInputSchema['~standard'].validate({ id: 1, a: 2, b: 3, c: 4 })
-    if (result instanceof Promise) {
-      throw new Error('Unexpected async schema result')
-    }
-    expect(result).toMatchObject({
-      value: {
-        id: '1',
-        a: '2',
-        b: '3',
-        c: '4',
-      },
-    })
-  })
-
-  it('flatInputSchema validate error', () => {
-    const route = Route0.create('/:id&a&b')
-    const result = route.flatInputSchema['~standard'].validate(undefined)
-    if (result instanceof Promise) {
-      throw new Error('Unexpected async schema result')
-    }
-    expect(result).toMatchObject({
-      issues: [{ message: 'Missing params: "id"' }],
-    })
-  })
-
-  it('flatInputSchema parse and safeParse', () => {
-    const route = Route0.create('/:id&a&')
-    expect(route.flatInputSchema.parse({ id: 1, a: 2, c: 3 })).toMatchObject({
-      id: '1',
-      a: '2',
-      c: '3',
-    })
-    expect(route.flatInputSchema.safeParse({ id: 1, a: 2, c: 3 })).toMatchObject({
-      success: true,
-      data: {
-        id: '1',
-        a: '2',
-        c: '3',
-      },
-      error: undefined,
-    })
-    expect(route.flatInputSchema.safeParse(undefined)).toMatchObject({
-      success: false,
-      data: undefined,
-      error: new Error('Missing params: "id"'),
-    })
-    expect(() => route.flatInputSchema.parse(undefined)).toThrow('Missing params: "id"')
-  })
-
-  it('paramsInputSchema validate', () => {
+describe('params schema', () => {
+  it('paramsSchema validate', () => {
     const route = Route0.create('/:id/:sn')
-    const result = route.paramsInputSchema['~standard'].validate({ id: 1, sn: 'x', extra: 'ignored' })
+    const result = route.paramsSchema['~standard'].validate({ id: 1, sn: 'x', extra: 'ignored' })
     if (result instanceof Promise) {
       throw new Error('Unexpected async schema result')
     }
@@ -1374,78 +1185,20 @@ describe('input schemas', () => {
     })
   })
 
-  it('strictSearchInputSchema validate', () => {
-    const route = Route0.create('/:id&a&b')
-    const result = route.strictSearchInputSchema['~standard'].validate({ id: '1', a: 2, b: '3', c: 4 })
-    if (result instanceof Promise) {
-      throw new Error('Unexpected async schema result')
-    }
-    expect(result).toMatchObject({
-      value: { a: '2', b: '3' },
-    })
-  })
-
-  it('looseSearchInputSchema validate', () => {
-    const route = Route0.create('/:id&a&')
-    const result = route.looseSearchInputSchema['~standard'].validate({ id: '1', a: 2, b: '3', hash: 'x' })
-    if (result instanceof Promise) {
-      throw new Error('Unexpected async schema result')
-    }
-    expect(result).toMatchObject({
-      value: { a: '2', b: '3' },
-    })
-  })
-
-  it('params/search schemas parse and safeParse', () => {
-    const route = Route0.create('/:id&a&b')
-
-    expect(route.paramsInputSchema.parse({ id: 1, x: '2' })).toMatchObject({ id: '1' })
-    expect(route.paramsInputSchema.safeParse(undefined)).toMatchObject({
+  it('paramsSchema parse and safeParse', () => {
+    const route = Route0.create('/:id')
+    expect(route.paramsSchema.parse({ id: 1, x: '2' })).toMatchObject({ id: '1' })
+    expect(route.paramsSchema.safeParse(undefined)).toMatchObject({
       success: false,
       data: undefined,
       error: new Error('Missing params: "id"'),
     })
-
-    expect(route.strictSearchInputSchema.parse({ id: '1', a: 2, b: 3, c: 4 })).toMatchObject({
-      a: '2',
-      b: '3',
-    })
-    expect(route.strictSearchInputSchema.safeParse({ a: () => ({}) })).toMatchObject({
-      success: false,
-      data: undefined,
-      error: new Error('Invalid input: expected string, number, or undefined, got function for "a"'),
-    })
-
-    expect(route.looseSearchInputSchema.parse({ id: '1', a: 2, c: 3 })).toMatchObject({
-      a: '2',
-      c: '3',
-    })
-    expect(route.looseSearchInputSchema.safeParse({ a: () => ({}) })).toMatchObject({
-      success: false,
-      data: undefined,
-      error: new Error('Invalid input: expected string, number, or undefined, got function for "a"'),
-    })
   })
 
   it('schema types are assignable to StandardSchemaV1', () => {
-    const route = Route0.create('/:id&a&')
-    expectTypeOf(route.paramsInputSchema).toMatchTypeOf<StandardSchemaV1>()
-    expectTypeOf(route.strictSearchInputSchema).toMatchTypeOf<StandardSchemaV1>()
-    expectTypeOf(route.looseSearchInputSchema).toMatchTypeOf<StandardSchemaV1>()
-    expectTypeOf(route.flatInputSchema).toMatchTypeOf<StandardSchemaV1>()
-
-    expectTypeOf(route.paramsInputSchema).toMatchTypeOf<
-      StandardSchemaV1<ParamsInput<'/:id&a&'>, ParamsOutput<'/:id&a&'>>
-    >()
-    expectTypeOf(route.strictSearchInputSchema).toMatchTypeOf<
-      StandardSchemaV1<StrictSearchInput<'/:id&a&'>, StrictSearchOutput<'/:id&a&'>>
-    >()
-    expectTypeOf(route.looseSearchInputSchema).toMatchTypeOf<
-      StandardSchemaV1<LooseSearchInput<'/:id&a&'>, LooseSearchOutput<'/:id&a&'>>
-    >()
-    expectTypeOf(route.flatInputSchema).toMatchTypeOf<
-      StandardSchemaV1<LooseFlatInput<'/:id&a&'>, LooseFlatOutput<'/:id&a&'>>
-    >()
+    const route = Route0.create('/:id')
+    expectTypeOf(route.paramsSchema).toExtend<StandardSchemaV1>()
+    expectTypeOf(route.paramsSchema).toExtend<StandardSchemaV1<ParamsInput<'/:id'>, ParamsOutput<'/:id'>>>()
   })
 })
 
@@ -1501,18 +1254,17 @@ describe('Routes', () => {
   it('create with params and search', () => {
     const collection = Routes.create({
       user: '/user/:id',
-      search: '/search&q&filter',
-      userWithSearch: '/user/:id&tab',
+      search: Route0.create('/search').search<{ q: string; filter: string }>(),
+      userWithSearch: Route0.create('/user/:id').search<{ tab: string }>(),
     })
-
     const user = collection.user
     expect(user.get({ id: '123' })).toBe('/user/123')
-
     const search = collection.search
-    expect(search.get({ search: { q: 'test', filter: 'all' } })).toBe('/search?q=test&filter=all')
-
+    expect(search.get({ '?': { q: 'test', filter: 'all' } })).toBe('/search?q=test&filter=all')
     const userWithSearch = collection.userWithSearch
-    expect(userWithSearch.get({ id: '456', search: { tab: 'posts' } })).toBe('/user/456?tab=posts')
+    expect(userWithSearch.get({ id: '456', '?': { tab: 'posts' } })).toBe('/user/456?tab=posts')
+    // @ts-expect-error invalid search param key
+    expect(userWithSearch.get({ id: '456', '?': { zxc: 'posts' } })).toBe('/user/456?zxc=posts')
   })
 
   it('get maintains route definitions', () => {
@@ -1527,8 +1279,6 @@ describe('Routes', () => {
     // Verify route definitions are preserved
     expect(home.definition).toBe('/')
     expect(user.definition).toBe('/user/:id')
-    expect(home.pathDefinition).toBe('/')
-    expect(user.pathDefinition).toBe('/user/:id')
 
     // Verify params work correctly
     expect(user.get({ id: '123' })).toBe('/user/123')
@@ -1545,8 +1295,8 @@ describe('Routes', () => {
     const home = overridden.home
     const about = overridden.about
 
-    expect(home.get({ abs: true })).toBe('https://example.com')
-    expect(about.get({ abs: true })).toBe('https://example.com/about')
+    expect(home.get(true)).toBe('https://example.com')
+    expect(about.get(true)).toBe('https://example.com/about')
   })
 
   it('clone does not mutate original', () => {
@@ -1558,13 +1308,13 @@ describe('Routes', () => {
     )
 
     const original = collection.home
-    expect(original.get({ abs: true })).toBe('https://example.com')
+    expect(original.get(true)).toBe('https://example.com')
 
     const overridden = collection._.clone({ origin: 'https://newdomain.com' })
     const newRoute = overridden.home
 
-    expect(original.get({ abs: true })).toBe('https://example.com')
-    expect(newRoute.get({ abs: true })).toBe('https://newdomain.com')
+    expect(original.get(true)).toBe('https://example.com')
+    expect(newRoute.get(true)).toBe('https://newdomain.com')
   })
 
   it('clone with extended routes', () => {
@@ -1576,14 +1326,14 @@ describe('Routes', () => {
       users: usersRoute,
     })
 
-    expect(collection.api.get({ abs: true })).toBe('https://api.example.com/api')
-    expect(collection.api({ abs: true })).toBe('https://api.example.com/api')
-    expect(collection.users.get({ abs: true })).toBe('https://api.example.com/api/users')
+    expect(collection.api.get(true)).toBe('https://api.example.com/api')
+    expect(collection.api(true)).toBe('https://api.example.com/api')
+    expect(collection.users.get(true)).toBe('https://api.example.com/api/users')
 
     const overridden = collection._.clone({ origin: 'https://new-api.example.com' })
 
-    expect(overridden.api.get({ abs: true })).toBe('https://new-api.example.com/api')
-    expect(overridden.users.get({ abs: true })).toBe('https://new-api.example.com/api/users')
+    expect(overridden.api.get(true)).toBe('https://new-api.example.com/api')
+    expect(overridden.users.get(true)).toBe('https://new-api.example.com/api/users')
   })
 
   it('hydrate static method', () => {
@@ -1626,21 +1376,23 @@ describe('Routes', () => {
       api,
       users: api.extend('/users'),
       userDetail: api.extend('/users/:id'),
-      userPosts: api.extend('/users/:id/posts&sort&filter'),
+      userPosts: api.extend('/users/:id/posts').search<{ sort: string; filter: string }>(),
     })
 
     expect(collection.root.get()).toBe('/')
-    expect(collection.api({ abs: true })).toBe('https://api.example.com/api/v1')
-    expect(collection.users.get({ abs: true })).toBe('https://api.example.com/api/v1/users')
+    expect(collection.api(true)).toBe('https://api.example.com/api/v1')
+    expect(collection.users.get(true)).toBe('https://api.example.com/api/v1/users')
 
-    const userDetailPath = collection.userDetail.get({ id: '42', abs: true })
+    const userDetailPath = collection.userDetail.get({ id: '42' }, true)
     expect(userDetailPath).toBe('https://api.example.com/api/v1/users/42')
 
-    const userPostsPath = collection.userPosts.get({
-      id: '42',
-      search: { sort: 'date', filter: 'published' },
-      abs: true,
-    })
+    const userPostsPath = collection.userPosts.get(
+      {
+        id: '42',
+        '?': { sort: 'date', filter: 'published' },
+      },
+      true,
+    )
     expect(userPostsPath).toBe('https://api.example.com/api/v1/users/42/posts?sort=date&filter=published')
   })
 })
@@ -1750,6 +1502,19 @@ describe('specificity', () => {
     // Same depth but different static segments
     expect(route1.isConflict(route2)).toBe(false)
   })
+
+  it('isMayBeSame: optional params can overlap static', () => {
+    const optional = Route0.create('/users/:id?')
+    const staticUsers = Route0.create('/users')
+    expect(optional.isSame(staticUsers)).toBe(false)
+    expect(optional.isMayBeSame(staticUsers)).toBe(true)
+  })
+
+  it('isConflict: wildcard overlaps deeper static routes', () => {
+    const wildcard = Route0.create('/app*')
+    const staticRoute = Route0.create('/app/home')
+    expect(wildcard.isConflict(staticRoute)).toBe(true)
+  })
 })
 
 describe('regex', () => {
@@ -2153,6 +1918,29 @@ describe('ordering', () => {
     expect(ordering).toEqual(['/about', '/contact', '/home'])
   })
 
+  it('_makeOrdering: keeps concrete routes before wildcard overlaps', () => {
+    const routes = {
+      appWildcard: '/app*',
+      appHome: '/app/home',
+      app: '/app',
+    }
+    const { pathsOrdering: ordering } = Routes._.makeOrdering(routes)
+    expect(ordering).toEqual(['/app', '/app/home', '/app*'])
+  })
+
+  it('_makeOrdering: mixed optional and required params are deterministic', () => {
+    const routes = {
+      usersOptional: '/users/:id?',
+      usersRequired: '/users/:id',
+      usersStatic: '/users/new',
+      usersWildcard: '/users/*?',
+    }
+    const { pathsOrdering: ordering } = Routes._.makeOrdering(routes)
+    expect(ordering.indexOf('/users/new')).toBeLessThan(ordering.indexOf('/users/:id'))
+    expect(ordering.indexOf('/users/:id')).toBeLessThan(ordering.indexOf('/users/:id?'))
+    expect(ordering.indexOf('/users/:id?')).toBeLessThan(ordering.indexOf('/users/*?'))
+  })
+
   it('_makeOrdering: complex nested structure', () => {
     const api = Route0.create('/api/v1')
     const routes = {