polen 0.10.0 → 0.11.0-next.10

package/src/api/vite/plugins/schema-assets.ts

@@ -0,0 +1,364 @@
+import type { Config } from '#api/config/index'
+import { SchemaAugmentation } from '#api/schema-augmentation/index'
+import { createSchemaSource } from '#api/schema-source/index'
+import { Schema } from '#api/schema/index'
+import type { Vite } from '#dep/vite/index'
+import { Grafaid } from '#lib/grafaid/index'
+import { ViteVirtual } from '#lib/vite-virtual/index'
+import { debugPolen } from '#singletons/debug'
+import { Cache } from '@wollybeard/kit'
+import * as NodeFs from 'node:fs/promises'
+import * as NodePath from 'node:path'
+import type { NonEmptyChangeSets } from '../../schema/schema.js'
+import { polenVirtual } from '../vi.js'
+
+export const viProjectSchemaMetadata = polenVirtual([`project`, `schema-metadata`])
+
+/**
+ * Vite plugin that generates JSON assets for GraphQL schemas at build time.
+ *
+ * This plugin:
+ * - Reads GraphQL schema files from the project
+ * - Applies schema augmentations
+ * - Converts schemas to AST format and emits as JSON assets
+ * - Creates a metadata file with available versions
+ * - Provides a virtual module for accessing schema metadata
+ *
+ * The generated assets enable client-side loading of different schema versions
+ * without requiring all schemas to be bundled into the main JavaScript bundle.
+ *
+ * @param config - Polen configuration object
+ * @returns Vite plugin instance
+ */
+export const SchemaAssets = (config: Config.Config): Vite.Plugin => {
+  const debug = debugPolen.sub(`vite-plugin:schema-assets`)
+  let viteServer: Vite.ViteDevServer | null = null
+
+  // Helper to load and process schema data
+  const loadAndProcessSchemaData = Cache.memoize(async () => {
+    const schemaResult = await Schema.readOrThrow({
+      ...config.schema,
+      projectRoot: config.paths.project.rootDir,
+    })
+
+    if (!schemaResult.data) {
+      const metadata: Schema.SchemaMetadata = { hasSchema: false, versions: [] }
+      return {
+        schemaData: null,
+        metadata,
+        source: schemaResult.source,
+      }
+    }
+
+    // Apply augmentations
+    schemaResult.data.forEach(version => {
+      SchemaAugmentation.apply(version.after, config.schemaAugmentations)
+    })
+
+    // Build metadata
+    const versionStrings: string[] = []
+    for (const [index, version] of schemaResult.data.entries()) {
+      const versionName = index === 0 ? Schema.VERSION_LATEST : Schema.dateToVersionString(version.date)
+      versionStrings.push(versionName)
+    }
+
+    const metadata = {
+      hasSchema: true,
+      versions: versionStrings,
+    }
+
+    debug(`schemaDataLoaded`, { versionCount: schemaResult.data.length })
+
+    return {
+      schemaData: schemaResult.data,
+      metadata,
+      source: schemaResult.source,
+    }
+  })
+
+  // Helper to create schema source with filesystem IO
+  const createDevSchemaSource = (metadata: Schema.SchemaMetadata) => {
+    return createSchemaSource({
+      io: {
+        read: async () => {
+          throw new Error('Read not supported in dev asset writer')
+        },
+        write: async (path: string, content: string) => {
+          await NodeFs.writeFile(path, content, 'utf-8')
+        },
+        clearDirectory: async (path: string) => {
+          try {
+            const files = await NodeFs.readdir(path)
+            await Promise.all(files.map(file => NodeFs.rm(NodePath.join(path, file), { force: true })))
+          } catch (error) {
+            // Directory might not exist, which is fine
+          }
+        },
+        removeFile: async (path: string) => {
+          await NodeFs.rm(path, { force: true })
+        },
+      },
+      versions: metadata.versions,
+      assetsPath: config.paths.framework.devAssets.absolute,
+    })
+  }
+
+  // Helper to write assets using schema-source API
+  const writeDevAssets = async (
+    schemaData: NonEmptyChangeSets,
+    metadata: Schema.SchemaMetadata,
+  ) => {
+    // schemaData is now guaranteed to be non-null NonEmptyChangeSets
+
+    const devAssetsDir = config.paths.framework.devAssets.schemas
+    await NodeFs.mkdir(devAssetsDir, { recursive: true })
+
+    const schemaSource = createDevSchemaSource(metadata)
+    await schemaSource.writeAllAssets(schemaData, metadata)
+    debug(`devAssetsWritten`, { versionCount: schemaData.length })
+  }
+
+  return {
+    name: `polen:schema-assets`,
+
+    configureServer(server) {
+      viteServer = server
+
+      // Clear all assets when dev server starts
+      const clearAssets = async () => {
+        try {
+          // Create a basic schema source just for clearing
+          const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
+          await schemaSource.clearAllAssets()
+          debug(`devAssetsCleared`, {})
+        } catch (error) {
+          // Ignore errors during clearing
+        }
+      }
+
+      // Clear assets immediately
+      void clearAssets()
+
+      // Set up file watching for schema source files
+      if (config.schema?.dataSources?.directory?.path) {
+        // Watch the entire directory for directory mode
+        server.watcher.add(config.schema.dataSources.directory.path)
+        debug(`watchingSchemaDirectory`, { path: config.schema.dataSources.directory.path })
+      }
+
+      if (config.schema?.dataSources?.file?.path) {
+        // Watch the specific file for file mode
+        server.watcher.add(config.schema.dataSources.file.path)
+        debug(`watchingSchemaFile`, { path: config.schema.dataSources.file.path })
+      }
+
+      if (config.schema?.dataSources?.introspection?.url) {
+        // Watch the introspection file if introspection is configured
+        const introspectionFilePath = NodePath.join(config.paths.project.rootDir, `schema.introspection.json`)
+        server.watcher.add(introspectionFilePath)
+        debug(`watchingIntrospectionFile`, { path: introspectionFilePath })
+      }
+
+      // Handle file removal
+      server.watcher.on('unlink', async (file) => {
+        const isSchemaFile = config.schema && (() => {
+          const absoluteFile = NodePath.resolve(file)
+
+          // Check if file path matches the configured schema file
+          if (config.schema.dataSources?.file?.path) {
+            const absoluteSchemaFile = NodePath.resolve(
+              config.paths.project.rootDir,
+              config.schema.dataSources.file.path,
+            )
+            if (absoluteFile === absoluteSchemaFile) return true
+          }
+
+          // Check if file path is within the configured schema directory
+          if (config.schema.dataSources?.directory?.path) {
+            const absoluteSchemaDir = NodePath.resolve(
+              config.paths.project.rootDir,
+              config.schema.dataSources.directory.path,
+            )
+            if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
+          }
+
+          // Check if file is the introspection file
+          if (config.schema.dataSources?.introspection?.url) {
+            const absoluteIntrospectionFile = NodePath.resolve(
+              config.paths.project.rootDir,
+              `schema.introspection.json`,
+            )
+            if (absoluteFile === absoluteIntrospectionFile) return true
+          }
+
+          return false
+        })()
+
+        if (isSchemaFile) {
+          debug(`schemaFileRemoved`, { file })
+
+          try {
+            // Clear cache and regenerate
+            loadAndProcessSchemaData.clear()
+            const { schemaData, metadata, source } = await loadAndProcessSchemaData()
+
+            // If file was deleted but can be recreated, attempt recreation
+            if (!schemaData && source.reCreate) {
+              debug(`attemptingSchemaRecreation`, { sourceType: source.type })
+              try {
+                const recreatedData = await source.reCreate()
+                if (recreatedData) {
+                  // Clear cache again and reload after recreation
+                  loadAndProcessSchemaData.clear()
+                  const reloadResult = await loadAndProcessSchemaData()
+                  if (reloadResult.schemaData) {
+                    await writeDevAssets(reloadResult.schemaData, reloadResult.metadata)
+                    debug(`hmr:schemaRecreatedAndWritten`, { versionCount: reloadResult.schemaData.length })
+                  }
+                } else {
+                  debug(`hmr:schemaRecreationFailed`, { reason: 'reCreate returned null' })
+                }
+              } catch (recreationError) {
+                debug(`hmr:schemaRecreationFailed`, { error: recreationError })
+              }
+            } else if (schemaData) {
+              // Write new assets without the removed file
+              await writeDevAssets(schemaData, metadata)
+              debug(`hmr:schemaAssetsUpdatedAfterRemoval`, { versionCount: schemaData.length })
+            } else {
+              // No schema data and cannot recreate - clear all assets
+              const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
+              await schemaSource.clearAllAssets()
+              debug(`hmr:allAssetsCleared`, {})
+            }
+          } catch (error) {
+            debug(`hmr:schemaRemovalFailed`, { error })
+          }
+
+          // Send HMR invalidation signal
+          server.ws.send({
+            type: 'custom',
+            event: 'polen:schema-invalidate',
+            data: { timestamp: Date.now() },
+          })
+
+          debug(`hmr:schemaInvalidationSent`, {})
+        }
+      })
+    },
+
+    async buildStart() {
+      debug(`buildStart`, {})
+
+      // Load and process schema data
+      const { schemaData, metadata } = await loadAndProcessSchemaData()
+
+      if (!schemaData) {
+        debug(`noSchemaFound`, {})
+        return
+      }
+
+      // Handle asset generation differently for dev vs build
+      if (viteServer) {
+        // Dev mode: Write assets directly to filesystem
+        await writeDevAssets(schemaData, metadata)
+        debug(`devMode:schemaAssetsWritten`, {})
+        return
+      }
+
+      // Build mode: Create schema source for emitting files
+      const schemaSource = createSchemaSource({
+        io: {
+          read: async () => {
+            throw new Error('Read not supported in build asset emitter')
+          },
+          write: async (path: string, content: string) => {
+            // Convert absolute path to relative filename for Vite
+            const relativePath = NodePath.relative(config.paths.framework.devAssets.absolute, path)
+            const fileName = `${config.paths.project.relative.build.relative.assets.root}/${relativePath}`
+
+            this.emitFile({
+              type: `asset`,
+              fileName,
+              source: content,
+            })
+          },
+        },
+        versions: metadata.versions,
+        assetsPath: config.paths.framework.devAssets.absolute,
+      })
+
+      // Emit all assets using the high-level API
+      await schemaSource.writeAllAssets(schemaData, metadata)
+      debug(`buildMode:allAssetsEmitted`, { versionCount: schemaData.length })
+    },
+
+    async handleHotUpdate({ file, server }) {
+      const isSchemaFile = config.schema && (() => {
+        const absoluteFile = NodePath.resolve(file)
+
+        // Check if file path matches the configured schema file
+        if (config.schema.dataSources?.file?.path) {
+          const absoluteSchemaFile = NodePath.resolve(config.paths.project.rootDir, config.schema.dataSources.file.path)
+          if (absoluteFile === absoluteSchemaFile) return true
+        }
+
+        // Check if file path is within the configured schema directory
+        if (config.schema.dataSources?.directory?.path) {
+          const absoluteSchemaDir = NodePath.resolve(
+            config.paths.project.rootDir,
+            config.schema.dataSources.directory.path,
+          )
+          if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
+        }
+
+        // Check if file is the introspection file
+        if (config.schema.dataSources?.introspection?.url) {
+          const absoluteIntrospectionFile = NodePath.resolve(
+            config.paths.project.rootDir,
+            `schema.introspection.json`,
+          )
+          if (absoluteFile === absoluteIntrospectionFile) return true
+        }
+
+        return false
+      })()
+      if (isSchemaFile) {
+        debug(`schemaFileChanged`, { file })
+
+        // Regenerate schema assets
+        try {
+          loadAndProcessSchemaData.clear()
+          const { schemaData, metadata } = await loadAndProcessSchemaData()
+
+          if (schemaData) {
+            debug(`hmr:schemaRegenerated`, { versionCount: schemaData.length })
+
+            // Write new assets to filesystem
+            await writeDevAssets(schemaData, metadata)
+          }
+        } catch (error) {
+          debug(`hmr:schemaRegenerationFailed`, { error })
+        }
+
+        // Send HMR invalidation signal
+        server.ws.send({
+          type: 'custom',
+          event: 'polen:schema-invalidate',
+          data: { timestamp: Date.now() },
+        })
+
+        debug(`hmr:schemaInvalidationSent`, {})
+      }
+    },
+
+    ...ViteVirtual.IdentifiedLoader.toHooks({
+      identifier: viProjectSchemaMetadata,
+      async loader() {
+        debug(`virtualModuleLoad`, { id: viProjectSchemaMetadata.id })
+        const { metadata } = await loadAndProcessSchemaData()
+        return `export default ${JSON.stringify(metadata)}`
+      },
+    }),
+  }
+}

package/src/api/vite/plugins/serve.ts

@@ -5,16 +5,10 @@ import type { Vite } from '#dep/vite/index'
 import { createHtmlTransformer } from '#lib/html-utils/html-transformer'
 import { ResponseInternalServerError } from '#lib/kit-temp'
 import { debugPolen } from '#singletons/debug'
+import type { App, AppOptions } from '#template/server/app'
 import * as HonoNodeServer from '@hono/node-server'
 import { Err } from '@wollybeard/kit'
-
-type App = Hono.Hono
-
-interface AppOptions {
-  hooks?: {
-    transformHtml?: ((html: string, ctx: Hono.Context) => Promise<string> | string)[]
-  }
-}
+import * as NodePath from 'node:path'
 
 interface AppServerModule {
   createApp: (options: AppOptions) => App
@@ -80,6 +74,19 @@ export const Serve = (
               }),
             ],
           },
+          paths: {
+            base: config.build.base,
+            assets: {
+              // Calculate relative path from CWD to Polen's assets
+              // CWD is user's project directory where they run 'pnpm dev'
+              // Assets are in Polen's dev assets directory
+              directory: NodePath.relative(
+                process.cwd(),
+                config.paths.framework.devAssets.absolute,
+              ),
+              route: config.server.routes.assets,
+            },
+          },
         })
       })
       .catch(async (error) => {

package/src/cli/commands/open.ts

@@ -132,7 +132,7 @@ const wrapCache = <fn extends Fn.AnyAnyAsync>(fn: fn): fn => {
 
 // todo: use a proper validation, e.g. zod, better yet: allow to specify the validation in molt itself
 const parseHeaders = (headersJsonEncoded: string): Record<string, string> => {
-  const headersJson = Json.codec.deserialize(headersJsonEncoded)
+  const headersJson = Json.codec.decode(headersJsonEncoded)
   if (!Rec.is(headersJson)) {
     console.log(`--introspection-headers must be a JSON object.`)
     process.exit(1)

package/src/lib/grafaid/schema/schema.ts

@@ -4,6 +4,7 @@ export {
   buildASTSchema as fromAST,
   buildClientSchema as fromIntrospectionQuery,
   GraphQLSchema as Schema,
+  introspectionFromSchema as toIntrospectionQuery,
   printSchema as print,
 } from 'graphql'
 

package/src/lib/graphql-change/change-groups.ts

@@ -1,3 +1,4 @@
+import { neverCase } from '@wollybeard/kit/language'
 import type {
   Change,
   DirectiveAddedChange,
@@ -248,3 +249,59 @@ export type DirectiveUsage =
   | DirectiveUsageInputFieldDefinitionRemovedChange
 
 export const isDirectiveUsage = (change: Change): change is DirectiveUsage => change.type.startsWith(`DIRECTIVE_USAGE_`)
+
+export type Type =
+  | 'TypeOperation'
+  | 'TypeDescription'
+  | 'FieldOperation'
+  | 'FieldDescription'
+  | 'FieldDeprecation'
+  | 'FieldDeprecationReason'
+  | 'FieldArgumentOperation'
+  | 'FieldArgument'
+  | 'FieldArgumentDescription'
+  | 'EnumValueOperation'
+  | 'EnumValueDescription'
+  | 'EnumValueDeprecationReason'
+  | 'InputFieldOperation'
+  | 'InputFieldDescription'
+  | 'InputFieldDefaultValue'
+  | 'UnionMemberOperation'
+  | 'ObjectTypeInterfaceOperation'
+  | 'DirectiveOperation'
+  | 'DirectiveDescription'
+  | 'DirectiveLocationOperation'
+  | 'DirectiveArgumentOperation'
+  | 'DirectiveArgument'
+  | 'DirectiveArgumentDescription'
+  | 'SchemaRootType'
+  | 'DirectiveUsage'
+
+export const getType = (change: Change): Type => {
+  if (isTypeOperation(change)) return 'TypeOperation'
+  if (isTypeDescription(change)) return 'TypeDescription'
+  if (isFieldOperation(change)) return 'FieldOperation'
+  if (isFieldDescription(change)) return 'FieldDescription'
+  if (isFieldDeprecation(change)) return 'FieldDeprecation'
+  if (isFieldDeprecationReason(change)) return 'FieldDeprecationReason'
+  if (isFieldArgumentOperation(change)) return 'FieldArgumentOperation'
+  if (isFieldArgument(change)) return 'FieldArgument'
+  if (isFieldArgumentDescription(change)) return 'FieldArgumentDescription'
+  if (isEnumValueOperation(change)) return 'EnumValueOperation'
+  if (isEnumValueDescription(change)) return 'EnumValueDescription'
+  if (isEnumValueDeprecationReason(change)) return 'EnumValueDeprecationReason'
+  if (isInputFieldOperation(change)) return 'InputFieldOperation'
+  if (isInputFieldDescription(change)) return 'InputFieldDescription'
+  if (isInputFieldDefaultValue(change)) return 'InputFieldDefaultValue'
+  if (isUnionMemberOperation(change)) return 'UnionMemberOperation'
+  if (isObjectTypeInterfaceOperation(change)) return 'ObjectTypeInterfaceOperation'
+  if (isDirectiveOperation(change)) return 'DirectiveOperation'
+  if (isDirectiveDescription(change)) return 'DirectiveDescription'
+  if (isDirectiveLocationOperation(change)) return 'DirectiveLocationOperation'
+  if (isDirectiveArgumentOperation(change)) return 'DirectiveArgumentOperation'
+  if (isDirectiveArgument(change)) return 'DirectiveArgument'
+  if (isDirectiveArgumentDescription(change)) return 'DirectiveArgumentDescription'
+  if (isSchemaRootType(change)) return 'SchemaRootType'
+  if (isDirectiveUsage(change)) return 'DirectiveUsage'
+  neverCase(change)
+}

package/src/lib/kit-temp.ts

@@ -105,9 +105,9 @@ export const objPolicyFilter = <
   const result: any = mode === `deny` ? { ...obj } : {}
 
   if (mode === `allow`) {
-    // For allow mode, only add specified keys
+    // For allow mode, only add specified keys that are own properties
     for (const key of keys) {
-      if (key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
         // @ts-expect-error
         result[key] = obj[key]
       }
@@ -181,6 +181,19 @@ export const ensureEnd = (string: string, ending: string) => {
   return string + ending
 }
 
+/**
+ * Create a generic cache with clear interface
+ */
+export const createCache = <T>() => {
+  const cache = new Map<string, T>()
+  return {
+    has: (key: string) => cache.has(key),
+    get: (key: string) => cache.get(key),
+    set: (key: string, value: T) => cache.set(key, value),
+    clear: () => cache.clear(),
+  }
+}
+
 export const ResponseInternalServerError = () =>
   new Response(null, {
     status: Http.Status.InternalServerError.code,

package/src/lib/mask/$.test.ts

@@ -113,9 +113,9 @@ describe('property-based tests', () => {
           // Result contains only keys that were in both mask and object
           expect(resultKeys.every(key => keys.includes(key))).toBe(true)
 
-          // All requested keys that exist in obj are in result
+          // All requested keys that are own properties of obj are in result
           keys.forEach(key => {
-            if (key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
               expect(result).toHaveProperty(key, (obj as any)[key])
             }
           })
@@ -169,7 +169,7 @@ describe('property-based tests', () => {
           const result = Mask.apply(obj as any, Mask.create(keys))
 
           keys.forEach(key => {
-            if (key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
               expect(result).toHaveProperty(key)
               expect((result as any)[key]).toBe((obj as any)[key])
             }

package/src/lib/path-map/$.test.ts

@@ -197,6 +197,22 @@ describe('PathMap', () => {
   })
 
   describe('property tests', () => {
+    // Helper to normalize base paths the same way PathMap.create does
+    const normalizeBasePath = (base: string): string => {
+      const trimmedBase = base.trim()
+      const collapsedBase = trimmedBase.replace(/\/+/g, '/')
+      const cleanedBase = collapsedBase === '/.' ? '/' : collapsedBase
+      return cleanedBase === '/' ? '/' : cleanedBase.replace(/\/$/, '')
+    }
+
+    // Helper to build absolute paths with proper handling of root base
+    const buildAbsolutePath = (normalizedBase: string, segments: string[]): string => {
+      if (segments.length === 0) return normalizedBase
+      return normalizedBase === '/'
+        ? `/${segments.join('/')}`
+        : `${normalizedBase}/${segments.join('/')}`
+    }
+
     // Arbitrary for valid path segments
     const pathSegment = fc.stringMatching(/^[a-zA-Z0-9_-]+$/)
 
@@ -243,10 +259,7 @@ describe('PathMap', () => {
       fc.assert(
         fc.property(pathInput, fc.string({ minLength: 1 }).filter(s => s.startsWith('/')), (input, base) => {
           const paths = PathMap.create(input, base)
-
-          // Base is normalized (trimmed, multiple slashes collapsed, trailing removed)
-          const collapsedBase = base.trim().replace(/\/+/g, '/')
-          const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
+          const normalizedBase = normalizeBasePath(base)
 
           function checkAbsolute(obj: any) {
             for (const [key, value] of Object.entries(obj)) {
@@ -278,14 +291,11 @@ describe('PathMap', () => {
             expect(JSON.stringify(p1.rooted)).toBe(JSON.stringify(p2.rooted))
 
             // Only absolute paths and base should change
-            const collapsedBase2 = base2.trim().replace(/\/+/g, '/')
-            const normalizedBase2 = collapsedBase2 === '/' ? '/' : collapsedBase2.replace(/\/$/, '')
-            expect(p2.base).toBe(normalizedBase2)
-
+            // Use the normalized base from the PathMap itself
             function checkBase(obj: any) {
               for (const [key, value] of Object.entries(obj)) {
                 if (typeof value === 'string') {
-                  expect(value.startsWith(normalizedBase2)).toBe(true)
+                  expect(value.startsWith(p2.base)).toBe(true)
                 } else if (typeof value === 'object') {
                   checkBase(value)
                 }
@@ -309,20 +319,13 @@ describe('PathMap', () => {
               if (currentPath.length === 0) {
                 expect(rel.$).toBe('.')
                 expect(rooted.$).toBe('.')
-                // Base is normalized in create() (trimmed, collapsed, trailing removed)
-                const collapsedBase = base.trim().replace(/\/+/g, '/')
-                const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
+                const normalizedBase = normalizeBasePath(base)
                 expect(abs.$).toBe(normalizedBase)
               } else {
                 expect(rel.$).toBe(currentPath[currentPath.length - 1])
                 expect(rooted.$).toBe(currentPath.join('/'))
-                // Handle base that might be '/' or have trailing slash
-                // Note: create() normalizes the base (trim + collapse + remove trailing)
-                const collapsedBase = base.trim().replace(/\/+/g, '/')
-                const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
-                const expectedAbs = normalizedBase === '/'
-                  ? `/${currentPath.join('/')}`
-                  : `${normalizedBase}/${currentPath.join('/')}`
+                const normalizedBase = normalizeBasePath(base)
+                const expectedAbs = buildAbsolutePath(normalizedBase, currentPath)
                 expect(abs.$).toBe(expectedAbs)
               }
             }

package/src/lib/path-map/path-map.ts

@@ -113,7 +113,9 @@ export function create<T extends PathInput>(paths: T, base?: string): RelativePa
   const trimmedBase = base.trim()
   // Collapse multiple slashes to single, then remove trailing (unless it's just "/")
   const collapsedBase = trimmedBase.replace(/\/+/g, `/`)
-  const normalizedBase = collapsedBase === `/` ? `/` : collapsedBase.replace(/\/$/, ``)
+  // Handle edge case where base is "/." - this should become "/"
+  const cleanedBase = collapsedBase === `/.` ? `/` : collapsedBase
+  const normalizedBase = cleanedBase === `/` ? `/` : cleanedBase.replace(/\/$/, ``)
 
   const rooted = processRootedPaths(paths, [])
   const absolute = processAbsolutePaths(paths, normalizedBase, [])

package/src/lib/react-router-aid/react-router-aid.ts

@@ -1,4 +1,5 @@
 import type { ReactRouter } from '#dep/react-router/index'
+import type { React } from '#dep/react/index'
 import type { Http } from '@wollybeard/kit'
 
 export * from './get-paths-patterns.js'
@@ -18,23 +19,28 @@ export interface RouteHandle {
   statusCode?: Http.Status.Code.All
 }
 
-export const createRoute = <routeObject extends RouteObject>(
+export const route = <routeObject extends RouteObject>(
   routeObject: routeObject,
 ): routeObject => {
   return {
-    id: routeObject.path,
     ...routeObject,
   }
 }
 
-export type RouteObjectIndexInput = Omit<RouteObjectIndex, `index` | `children`>
+export type RouteObjectIndexInput = RouteObjectIndexInputConfig | React.ComponentType
+export type RouteObjectIndexInputConfig = Omit<RouteObjectIndex, `index` | `children`>
 
-export const createRouteIndex = (
-  indexRouteObjectInput: RouteObjectIndexInput,
+export const routeIndex = (
+  input: RouteObjectIndexInput,
 ): RouteObjectIndex => {
+  const routeConfig: RouteObjectIndexInputConfig = isComponentType(input) ? { Component: input } : input
   return {
-    ...indexRouteObjectInput,
+    ...routeConfig,
     index: true,
     children: undefined,
   }
 }
+
+const isComponentType = (value: unknown): value is React.ComponentType => {
+  return typeof value === 'function'
+}