polen 0.8.0-next.9 → 0.8.1-next.1

package/src/lib/file-router/scan.ts

@@ -1,7 +1,9 @@
-import { TinyGlobby } from '#dep/tiny-globby/index.js'
+import { TinyGlobby } from '#dep/tiny-globby/index'
+import { Tree } from '#lib/tree/index'
 import { Path, Str } from '@wollybeard/kit'
-import { type Diagnostic, lint } from './linter.js'
-import type { Route, RouteFile, RouteLogical } from './route.js'
+import { type Diagnostic, lint } from './linter.ts'
+import { type Route, type RouteFile, type RouteLogical, routeToPathExpression } from './route.ts'
+import { scanTree } from './scan-tree.ts'
 
 //
 //
@@ -15,6 +17,9 @@ const conventions = {
   index: {
     name: `index`,
   },
+  numberedPrefix: {
+    pattern: Str.pattern<{ groups: ['order', 'name'] }>(/^(?<order>\d+)[_-](?<name>.+)$/),
+  },
 }
 
 //
@@ -42,18 +47,21 @@ export const scan = async (parameters: {
   dir: string
   glob?: string
 }): Promise<ScanResult> => {
-  const { dir, glob = `**/*` } = parameters
+  // Use tree-based scanner
+  const treeResult = await scanTree(parameters)
 
-  const filePathStrings = await TinyGlobby.glob(glob, {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
+  // Flatten tree to get routes
+  const routes: Route[] = []
+  Tree.visit(treeResult.routeTree, (node) => {
+    if (node.value.type === 'file' && node.value.route) {
+      routes.push(node.value.route)
+    }
   })
 
-  const routes: Route[] = filePathStrings.map(filePath => filePathToRoute(filePath, dir))
-
+  // Apply linting
   const lintResult = lint(routes)
 
+  // Routes are already sorted by the tree structure
   return lintResult
 }
 
@@ -75,15 +83,22 @@ export const filePathToRoute = (filePathExpression: string, rootDir: string): Ro
 export const filePathToRouteLogical = (filePath: Path.Parsed): RouteLogical => {
   const dirPath = Str.split(Str.removeSurrounding(filePath.dir, Path.sep), Path.sep)
 
-  if (Str.isMatch(filePath.name, conventions.index.name)) {
+  // Parse numbered prefix from filename
+  const prefixMatch = Str.match(filePath.name, conventions.numberedPrefix.pattern)
+  const order = prefixMatch ? parseInt(prefixMatch.groups.order, 10) : undefined
+  const nameWithoutPrefix = prefixMatch?.groups.name ?? filePath.name
+
+  if (nameWithoutPrefix === conventions.index.name) {
     const path = dirPath
     return {
       path,
+      order,
     }
   }
 
-  const path = dirPath.concat(filePath.name)
+  const path = dirPath.concat(nameWithoutPrefix)
   return {
     path,
+    order,
   }
 }

package/src/lib/file-router/sidebar/index.ts

@@ -0,0 +1,3 @@
+export * as SidebarTree from './sidebar-tree.ts'
+// Re-export SidebarTree as Sidebar for backward compatibility
+export * as Sidebar from './sidebar-tree.ts'

package/src/lib/file-router/sidebar/sidebar-tree.test.ts

@@ -0,0 +1,123 @@
+import { Tree } from '#lib/tree/index'
+import { describe, expect, test } from 'vitest'
+import type { RouteTreeNode, RouteTreeNodeValue } from '../scan-tree.ts'
+import { buildFromTree } from './sidebar-tree.ts'
+
+// Helper to create mock routes
+const mockRoute = (path: string[]) => ({
+  logical: { path },
+  file: {
+    path: {
+      absolute: { root: '/', dir: '/', base: 'file.md', ext: '.md', name: 'file' },
+      relative: { root: '', dir: '', base: 'file.md', ext: '.md', name: 'file' },
+    },
+  },
+})
+
+// Helper to create file node
+const fileNode = (name: string, route: any): RouteTreeNode =>
+  Tree.node<RouteTreeNodeValue>({ name, type: 'file', route })
+
+// Helper to create directory node
+const dirNode = (name: string, children: RouteTreeNode[] = []): RouteTreeNode =>
+  Tree.node<RouteTreeNodeValue>({ name, type: 'directory' }, children)
+
+describe('sidebar-tree', () => {
+  test('builds sidebar from simple tree', () => {
+    const tree = dirNode('root', [
+      fileNode('getting-started', mockRoute(['getting-started'])),
+      dirNode('guide', [
+        fileNode('introduction', mockRoute(['guide', 'introduction'])),
+        fileNode('basics', mockRoute(['guide', 'basics'])),
+      ]),
+    ])
+
+    const sidebar = buildFromTree(tree, [])
+
+    expect(sidebar.items).toHaveLength(2)
+    expect(sidebar.items[0]).toMatchObject({
+      type: 'ItemLink',
+      pathExp: 'getting-started',
+      title: 'Getting Started',
+    })
+    const section = sidebar.items[1]
+    expect(section).toBeDefined()
+    expect(section!.type).toBe('ItemSection')
+    if (section!.type === 'ItemSection') {
+      expect(section).toMatchObject({
+        type: 'ItemSection',
+        title: 'Guide',
+        pathExp: 'guide',
+        isNavToo: false,
+      })
+      expect(section!.navs).toHaveLength(2)
+    }
+  })
+
+  test('handles index files correctly', () => {
+    const tree = dirNode('root', [
+      dirNode('guide', [
+        fileNode('index', mockRoute(['guide'])),
+        fileNode('introduction', mockRoute(['guide', 'introduction'])),
+      ]),
+    ])
+
+    const sidebar = buildFromTree(tree, [])
+
+    expect(sidebar.items).toHaveLength(1)
+    const section = sidebar.items[0]
+    expect(section).toBeDefined()
+    expect(section!.type).toBe('ItemSection')
+    if (section!.type === 'ItemSection') {
+      expect(section).toMatchObject({
+        type: 'ItemSection',
+        title: 'Guide',
+        pathExp: 'guide',
+        isNavToo: true, // Should be true because of index file
+      })
+      expect(section!.navs).toHaveLength(1) // Only introduction, not index
+    }
+  })
+
+  test('respects node ordering from tree', () => {
+    const tree = dirNode('root', [
+      Tree.node<RouteTreeNodeValue>({ name: 'quickstart', order: 5, type: 'file', route: mockRoute(['quickstart']) }),
+      Tree.node<RouteTreeNodeValue>({ name: 'guide', order: 10, type: 'file', route: mockRoute(['guide']) }),
+      fileNode('api', mockRoute(['api'])),
+      fileNode('troubleshooting', mockRoute(['troubleshooting'])),
+    ])
+
+    const sidebar = buildFromTree(tree, [])
+
+    // Tree should already be sorted, so sidebar should maintain that order
+    const titles = sidebar.items.map(item => item.title)
+    expect(titles).toEqual(['Quickstart', 'Guide', 'Api', 'Troubleshooting'])
+  })
+
+  test('handles nested directories', () => {
+    const tree = dirNode('root', [
+      dirNode('guide', [
+        fileNode('intro', mockRoute(['guide', 'intro'])),
+        dirNode('advanced', [
+          fileNode('performance', mockRoute(['guide', 'advanced', 'performance'])),
+          fileNode('optimization', mockRoute(['guide', 'advanced', 'optimization'])),
+        ]),
+      ]),
+    ])
+
+    const sidebar = buildFromTree(tree, [])
+
+    expect(sidebar.items).toHaveLength(1)
+    const guideSection = sidebar.items[0]
+    expect(guideSection).toBeDefined()
+    expect(guideSection!.type).toBe('ItemSection')
+    if (guideSection!.type === 'ItemSection') {
+      expect(guideSection!.navs).toHaveLength(3) // intro + 2 from advanced subdirectory
+
+      const navTitles = guideSection!.navs.map(nav => nav.title)
+      expect(navTitles).toContain('Intro')
+      expect(navTitles).toContain('Performance')
+      expect(navTitles).toContain('Optimization')
+    }
+  })
+})

package/src/lib/file-router/sidebar/sidebar-tree.ts

@@ -0,0 +1,110 @@
+import { Tree } from '#lib/tree/index'
+import { Str } from '@wollybeard/kit'
+import * as FileRouter from '../file-router.ts'
+import type { RouteTreeNode, RouteTreeNodeValue } from '../scan-tree.ts'
+import type { ItemLink, ItemSection, Sidebar } from './types.ts'
+
+export * from './types.ts'
+
+/**
+ * Build sidebar from tree structure
+ */
+export const buildFromTree = (routeTree: RouteTreeNode, basePath: FileRouter.Path): Sidebar => {
+  const navs: ItemLink[] = []
+  const sections: ItemSection[] = []
+
+  // Process only the children of the root node
+  for (const child of routeTree.children) {
+    processNode(child, basePath, [], navs, sections)
+  }
+
+  const items = [...navs, ...sections]
+
+  return {
+    items,
+  }
+}
+
+const processNode = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  parentPath: string[],
+  navs: ItemLink[],
+  sections: ItemSection[],
+): void => {
+  const currentPath = [...parentPath, node.value.name]
+
+  if (node.value.type === 'directory') {
+    // This is a directory - create a section
+    const sectionPath = [...basePath, ...currentPath]
+    const sectionPathExp = FileRouter.pathToExpression(sectionPath)
+    const sectionTitle = Str.titlizeSlug(node.value.name)
+
+    const section: ItemSection = {
+      type: `ItemSection`,
+      title: sectionTitle,
+      pathExp: sectionPathExp.startsWith('/') ? sectionPathExp.slice(1) : sectionPathExp,
+      isNavToo: false,
+      navs: [],
+    }
+
+    // Check if this directory has an index file
+    const indexChild = node.children.find(child => child.value.type === 'file' && child.value.name === 'index')
+    if (indexChild) {
+      section.isNavToo = true
+    }
+
+    // Process all non-index children as navs for this section
+    for (const child of node.children) {
+      if (child.value.type === 'file' && child.value.name !== 'index' && child.value.route) {
+        // Pass the parent path of the route, not the section path
+        const routeParentPath = child.value.route.logical.path.slice(0, -1)
+        section.navs.push(routeToItemLink(child.value.route, routeParentPath))
+      } else if (child.value.type === 'directory') {
+        // Recursively process subdirectories
+        // Note: This creates nested sections which the original implementation doesn't support
+        // For now, we'll just add the files from subdirectories to the parent section
+        collectFilesFromDirectory(child, child.value.route?.logical.path || [], section.navs)
+      }
+    }
+
+    sections.push(section)
+  } else if (node.value.type === 'file' && node.value.route) {
+    // This is a top-level file - add as nav
+    if (node.value.name !== 'index') {
+      navs.push(routeToItemLink(node.value.route, basePath))
+    }
+  }
+}
+
+const collectFilesFromDirectory = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  navs: ItemLink[],
+): void => {
+  Tree.visit(node, (n) => {
+    if (n.value.type === 'file' && n.value.route && n.value.name !== 'index') {
+      // Use the route's parent path for relative title generation
+      const routeParentPath = n.value.route.logical.path.slice(0, -1)
+      navs.push(routeToItemLink(n.value.route, routeParentPath))
+    }
+  })
+}
+
+const routeToItemLink = (route: FileRouter.Route, basePath: FileRouter.Path): ItemLink => {
+  const pagePathExp = FileRouter.routeToPathExpression(route)
+  const pageRelative = FileRouter.makeRelativeUnsafe(route, basePath)
+  const pageRelativePathExp = FileRouter.routeToPathExpression(pageRelative)
+
+  // Remove leading slash for title generation
+  const titlePath = pageRelativePathExp.startsWith('/') ? pageRelativePathExp.slice(1) : pageRelativePathExp
+
+  // Use only the last segment for the title
+  const titleSegment = pageRelative.logical.path[pageRelative.logical.path.length - 1] || titlePath
+
+  return {
+    type: `ItemLink`,
+    pathExp: pagePathExp.startsWith('/') ? pagePathExp.slice(1) : pagePathExp,
+    title: Str.titlizeSlug(titleSegment),
+  }
+}

package/src/lib/file-router/sidebar/types.ts

@@ -0,0 +1,19 @@
+export interface Sidebar {
+  items: Item[]
+}
+
+export type Item = ItemLink | ItemSection
+
+export interface ItemLink {
+  type: `ItemLink`
+  title: string
+  pathExp: string
+}
+
+export interface ItemSection {
+  type: `ItemSection`
+  title: string
+  pathExp: string
+  isNavToo: boolean
+  navs: ItemLink[]
+}

package/src/lib/grafaid/_Nodes.ts

@@ -1 +1 @@
-export * as Nodes from './document.js'
+export * as Nodes from './document.ts'

package/src/lib/grafaid/document/OperationTypeNode.ts

@@ -5,4 +5,4 @@
 import type { OperationTypeNode as GraphQLOperationTypeNode } from 'graphql'
 
 export type OperationTypeNode = GraphQLOperationTypeNode
-export * as OperationTypeNode from './OperationTypeNodes.js'
+export * as OperationTypeNode from './OperationTypeNodes.ts'

package/src/lib/grafaid/document/kind.ts

@@ -4,6 +4,6 @@
 
 import type { Kind as GraphQLKind } from 'graphql'
 
-export * as Kind from './kinds.js'
+export * as Kind from './kinds.ts'
 
 export type Kind = GraphQLKind

package/src/lib/grafaid/document.ts

@@ -24,10 +24,10 @@ import {
   type VariableNode,
 } from 'graphql'
 import type { HasRequiredKeys } from 'type-fest'
-import { Kind } from './document/kind.js'
-import { OperationTypeNode } from './document/OperationTypeNode.js'
-// import type { RequestDocumentNodeInput } from './request.js'
-export { OperationType } from './schema/OperationType/__.js'
+import { Kind } from './document/kind.ts'
+import { OperationTypeNode } from './document/OperationTypeNode.ts'
+// import type { RequestDocumentNodeInput } from './request.ts'
+export { OperationType } from './schema/OperationType/__.ts'
 
 export type {
   ArgumentNode,
@@ -55,9 +55,9 @@ export type {
   VariableNode,
 } from 'graphql'
 
-export { OperationTypeNode } from './document/OperationTypeNode.js'
+export { OperationTypeNode } from './document/OperationTypeNode.ts'
 
-export { Kind } from './document/kind.js'
+export { Kind } from './document/kind.ts'
 
 export type $Any =
   | DirectiveNode

package/src/lib/grafaid/grafaid.ts

@@ -1,4 +1,4 @@
-export * as Document from './document.js'
-export * from './graphql.js'
-export * as HTTP from './http/http.js'
-export * as Schema from './schema/schema.js'
+export * as Document from './document.ts'
+export * from './graphql.ts'
+export * as HTTP from './http/http.ts'
+export * as Schema from './schema/schema.ts'

package/src/lib/grafaid/graphql.ts

@@ -1,8 +1,8 @@
 import { neverCase } from '@wollybeard/kit/language'
 import type { GraphQLNamedType, GraphQLScalarType } from 'graphql'
 import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isUnionType } from 'graphql'
-import type { KindMap } from './schema/schema.js'
-import { isScalarTypeCustom } from './schema/schema.js'
+import type { KindMap } from './schema/schema.ts'
+import { isScalarTypeCustom } from './schema/schema.ts'
 
 export {
   type ExecutionResult,
@@ -11,7 +11,7 @@ export {
   type GraphQLFormattedError as FormattedExecutionResultError,
 } from 'graphql'
 
-export * from './_Nodes.js'
+export * from './_Nodes.ts'
 
 export const StandardScalarTypeNames = {
   String: `String`,

package/src/lib/grafaid/http/__.ts

@@ -1 +1 @@
-export * as GraphQLHTTP from './http.js'
+export * as GraphQLHTTP from './http.ts'

package/src/lib/grafaid/http/http.ts

@@ -1,5 +1,5 @@
 import type { FormattedExecutionResult, GraphQLFormattedError } from 'graphql'
-// import { CONTENT_TYPE_GQL, CONTENT_TYPE_JSON } from '../../http.js'
+// import { CONTENT_TYPE_GQL, CONTENT_TYPE_JSON } from '../../http.ts'
 import { Rec } from '@wollybeard/kit'
 
 export interface RequestConfig {

package/src/lib/grafaid/index.ts

@@ -1 +1 @@
-export * as Grafaid from './grafaid.js'
+export * as Grafaid from './grafaid.ts'

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

@@ -1,10 +1,10 @@
 import type { GraphQLInterfaceType } from 'graphql'
-import { getRootTypeMap } from '../RootTypeMap.js'
-import type { Schema } from '../schema.js'
-import * as Type from '../type.js'
-import { isRoot } from '../type.js'
-import { isScalarTypeCustom } from '../typeGuards.js'
-import type { KindMap } from './__.js'
+import { getRootTypeMap } from '../RootTypeMap.ts'
+import type { Schema } from '../schema.ts'
+import * as Type from '../type.ts'
+import { isRoot } from '../type.ts'
+import { isScalarTypeCustom } from '../typeGuards.ts'
+import type { KindMap } from './__.ts'
 
 export const Name = {
   Root: `Root`,

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

@@ -6,9 +6,9 @@ import type {
   GraphQLScalarType,
   GraphQLUnionType,
 } from 'graphql'
-import type { RootTypeMap } from '../RootTypeMap.js'
+import type { RootTypeMap } from '../RootTypeMap.ts'
 
-export * as KindMap from './_.js'
+export * as KindMap from './_.ts'
 
 export interface KindMap {
   root: RootTypeMap

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

@@ -1,4 +1,4 @@
-import type { OperationTypeMutation, OperationTypeQuery, OperationTypeSubscription } from './_.js'
+import type { OperationTypeMutation, OperationTypeQuery, OperationTypeSubscription } from './_.ts'
 
-export * as OperationType from './_.js'
+export * as OperationType from './_.ts'
 export type OperationType = OperationTypeQuery | OperationTypeMutation | OperationTypeSubscription

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

@@ -1,7 +1,7 @@
 import type { GraphQLObjectType } from 'graphql'
-import { type OperationType, RootTypeToOperationType } from '../document.js'
-import type { RootTypeMap } from './RootTypeMap.js'
-import { type StandardRootTypeName } from './StandardRootTypeName.js'
+import { type OperationType, RootTypeToOperationType } from '../document.ts'
+import type { RootTypeMap } from './RootTypeMap.ts'
+import { type StandardRootTypeName } from './StandardRootTypeName.ts'
 
 /**
  * Details about if and how the root type name has been customized in this schema.

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

@@ -1,6 +1,6 @@
 import type { GraphQLObjectType, GraphQLSchema } from 'graphql'
-import { createFromObjectType, type RootDetails } from './RootDetails.js'
-import { type StandardRootTypeName, StandardRootTypeNameEnum } from './StandardRootTypeName.js'
+import { createFromObjectType, type RootDetails } from './RootDetails.ts'
+import { type StandardRootTypeName, StandardRootTypeNameEnum } from './StandardRootTypeName.ts'
 
 export interface RootTypeMap {
   list: RootDetails[]

package/src/lib/grafaid/schema/nodes-like.ts

@@ -1,6 +1,6 @@
 import type { GraphQLArgument, GraphQLEnumValue, GraphQLField, GraphQLInputField, GraphQLNamedType } from 'graphql'
-import { isOutputField } from './typeGuards.js'
-import type { Fielded } from './types-like.js'
+import { isOutputField } from './typeGuards.ts'
+import type { Fielded } from './types-like.ts'
 
 export type Field = GraphQLField<any, any> | GraphQLInputField
 

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

@@ -7,34 +7,34 @@ export {
   printSchema as print,
 } from 'graphql'
 
-export * as AST from './ast.js'
+export * as AST from './ast.ts'
 
-export * as Type from './type.js'
+export * as Type from './type.ts'
 
-export * from './type-class-name.js'
+export * from './type-class-name.ts'
 
-export * from './type-kind-name.js'
+export * from './type-kind-name.ts'
 
-export * from './RootDetails.js'
+export * from './RootDetails.ts'
 
-export * from './RootTypeMap.js'
+export * from './RootTypeMap.ts'
 
-export * from './StandardRootTypeName.js'
+export * from './StandardRootTypeName.ts'
 
-export * from './KindMap/__.js'
+export * from './KindMap/__.ts'
 
-export * from './typeGuards.js'
+export * from './typeGuards.ts'
 
-export * from './scalars.js'
+export * from './scalars.ts'
 
-export * as Args from './args.js'
+export * as Args from './args.ts'
 
-export * as TypesLike from './types-like.js'
+export * as TypesLike from './types-like.ts'
 
-export * as NodesLike from './nodes-like.js'
+export * as NodesLike from './nodes-like.ts'
 
-export * from './read.js'
+export * from './read.ts'
 
-import * as AST from './ast.js'
+import * as AST from './ast.ts'
 
 export const empty: GraphQLSchema = buildASTSchema(AST.empty)

package/src/lib/grafaid/schema/type-kind-name.ts

@@ -1,5 +1,5 @@
 import type { GraphQLNamedType } from 'graphql'
-import { TypeClassNameEnum, type TypeClassToName, typeClassToName } from './type-class-name.js'
+import { TypeClassNameEnum, type TypeClassToName, typeClassToName } from './type-class-name.ts'
 
 export const TypeKindNameEnum = {
   Scalar: `Scalar`,

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

@@ -9,7 +9,7 @@ import {
   type GraphQLUnionType,
   isNamedType,
 } from 'graphql'
-import type { RootTypeMap } from './RootTypeMap.js'
+import type { RootTypeMap } from './RootTypeMap.ts'
 
 // dprint-ignore
 export {

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

@@ -1,6 +1,6 @@
 import type { GraphQLInputObjectType } from 'graphql'
 import { type GraphQLField, type GraphQLScalarType, isNonNullType, isScalarType } from 'graphql'
-import { standardScalarTypeNames } from './scalars.js'
+import { standardScalarTypeNames } from './scalars.ts'
 
 export const isScalarTypeCustom = (node: GraphQLScalarType): boolean => {
   return !(node.name in standardScalarTypeNames)

package/src/lib/grafaid-old/grafaid.ts

@@ -29,7 +29,7 @@ import {
   isUnionType,
 } from 'graphql'
 
-export * as Schema from './schema.js'
+export * as Schema from './schema.ts'
 
 export namespace Groups {
   export type Describable = GraphQLNamedType | GraphQLField

package/src/lib/grafaid-old/index.ts

@@ -1 +1 @@
-export * as GrafaidOld from './grafaid.js'
+export * as GrafaidOld from './grafaid.ts'

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

@@ -1,5 +1,5 @@
-import { GraphqlInspector } from '#dep/graphql-inspector/index.js'
-import type { GrafaidOld } from '#lib/grafaid-old/index.js'
+import { GraphqlInspector } from '#dep/graphql-inspector/index'
+import type { GrafaidOld } from '#lib/grafaid-old/index'
 
 export type Change = GraphqlInspector.Core.SerializableChange & {
   message: string

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

@@ -1 +1 @@
-export * as GraphqlChange from './graphql-change.js'
+export * as GraphqlChange from './graphql-change.ts'

package/src/lib/graphql-changeset/graphql-changeset.ts

@@ -1,5 +1,5 @@
-import type { GrafaidOld } from '#lib/grafaid-old/index.js'
-import type { GraphqlChange } from '#lib/graphql-change/index.js'
+import type { GrafaidOld } from '#lib/grafaid-old/index'
+import type { GraphqlChange } from '#lib/graphql-change/index'
 
 export interface ChangeSet {
   after: GrafaidOld.Schema.Schema

package/src/lib/graphql-changeset/index.ts

@@ -1 +1 @@
-export * as GraphqlChangeset from './graphql-changeset.js'
+export * as GraphqlChangeset from './graphql-changeset.ts'

package/src/lib/graphql-schema-loader/graphql-schema-loader.ts

@@ -1,4 +1,4 @@
-import { Grafaid } from '#lib/grafaid/index.js'
+import { Grafaid } from '#lib/grafaid/index'
 import { Fs } from '@wollybeard/kit'
 import { neverCase } from '@wollybeard/kit/language'
 import { Graffle } from 'graffle'

package/src/lib/graphql-schema-loader/index.ts

@@ -1 +1 @@
-export * as GraphqlSchemaLoader from './graphql-schema-loader.js'
+export * as GraphqlSchemaLoader from './graphql-schema-loader.ts'

package/src/lib/hono-aid/hono-aid.ts

@@ -1,4 +1,4 @@
-import type { Hono } from '#dep/hono/index.js'
+import type { Hono } from '#dep/hono/index'
 import { Err, type Http } from '@wollybeard/kit'
 
 /** @see https://github.com/honojs/hono/issues/4051 */

package/src/lib/hono-aid/index.ts

@@ -1 +1 @@
-export * as HonoAid from './hono-aid.js'
+export * as HonoAid from './hono-aid.ts'