@goodandready/dsh-kanban 0.2.21 → 0.2.23

package/lib/git-provider.js

@@ -8,8 +8,8 @@
 export function createGitProvider({ gitea, github, getConfig }) {
   async function resolveActiveProvider(hint) {
     if (hint && typeof hint === 'object') {
-      if (hint.provider === 'github') return github
-      if (hint.provider === 'gitea') return gitea
+      if (hint.forge === 'github' || hint.provider === 'github') return github
+      if (hint.forge === 'gitea' || hint.provider === 'gitea') return gitea
       if (typeof hint.issueUrl === 'string' && hint.issueUrl.includes('github.com')) {
         return github
       }
@@ -58,6 +58,15 @@ export function createGitProvider({ gitea, github, getConfig }) {
       return p.me()
     },
 
+    /** Create repository. */
+    async createRepo(options) {
+      const p = forTarget(options?.provider) || await resolveActiveProvider(options)
+      if (typeof p?.createRepo !== 'function') {
+        throw Object.assign(new Error('Repository creation not supported by provider'), { code: 'not-supported' })
+      }
+      return p.createRepo(options)
+    },
+
     /** List issues. */
     async listIssues(options) {
       const p = forTarget(options?.provider) || await resolveActiveProvider(options)

package/lib/github.js

@@ -188,6 +188,16 @@ export function createGitHubClient({ getConfig, resolveToken, fetchImpl = fetch,
       return request('POST', repoPath(owner, repo, `/issues/${n}/comments`), { body })
     },
 
+    /** Create private, empty repository in organization or user account. */
+    async createRepo({ owner, name, description = '' }) {
+      const safe = safeSegment(name)
+      if (safe === undefined) throw Object.assign(new Error('invalid name'), { code: 'bad-segment' })
+      const path = owner ? `/orgs/${safeSegment(owner)}/repos` : '/user/repos'
+      return request('POST', path, {
+        name: safe, description, private: true, auto_init: false,
+      })
+    },
+
     /** Create new issue. */
     async createIssue({ owner, repo, title, body }) {
       const name = String(title ?? '').trim()

package/lib/import.js

@@ -152,24 +152,24 @@ export async function giteaState(gitea) {
 }
 
 /** List open issues for import dialog, marking already-imported ones. */
-export async function listImportable({ gitea, store, owner, repo, board = 'main' }) {
+export async function listImportable({ gitea, store, owner, repo, board = 'main', provider, forge }) {
   const state = await giteaState(gitea)
   if (state !== 'ready') return { error: `gitea-${state}`, status: 409 }
-  const issues = await gitea.listIssues({ owner, repo, state: 'open' })
+  const issues = await gitea.listIssues({ owner, repo, state: 'open', provider: forge || provider })
   const existing = store.listTasks({ board })
   return { issues: markImported(issues, existing, { owner, repo }) }
 }
 
 /** Create a task from an issue. */
-export async function importIssue({ gitea, store, owner, repo, issueNumber, board = 'main', column = 'backlog' }) {
+export async function importIssue({ gitea, store, owner, repo, issueNumber, board = 'main', column = 'backlog', provider, forge }) {
   const state = await giteaState(gitea)
   if (state !== 'ready') return { error: `gitea-${state}`, status: 409 }
   if (typeof issueNumber !== 'number') return { error: 'issue-number-required', status: 400 }
   // Simple board is for non-issue tasks. Importing here would bring branches/PRs into columns unable to display them.
   if (store.boardKind(board) !== 'project') return { error: 'board-not-for-issues', status: 400 }
-  const issue = await gitea.getIssue({ owner, repo, index: issueNumber })
+  const issue = await gitea.getIssue({ owner, repo, index: issueNumber, provider: forge || provider })
   if (issue === undefined || issue === null) return { error: 'issue-not-found', status: 404 }
-  return { task: store.createTask(issueToTask(issue, { board, column, owner, repo })) }
+  return { task: store.createTask(issueToTask(issue, { board, column, owner, repo, forge: forge || provider })) }
 }
 
 /** Re-read issue and update task, preserving local state. */
@@ -179,7 +179,8 @@ export async function refreshTask({ gitea, store, id }) {
   const task = store.getTask(id)
   if (task === undefined) return { error: 'task-not-found', status: 404 }
   if (typeof task.issueNumber !== 'number') return { error: 'task-has-no-issue', status: 400 }
-  const issue = await gitea.getIssue({ owner: task.owner, repo: task.repo, index: task.issueNumber })
+  const forge = task.forge || (typeof task.issueUrl === 'string' && task.issueUrl.includes('github.com') ? 'github' : 'gitea')
+  const issue = await gitea.getIssue({ owner: task.owner, repo: task.repo, index: task.issueNumber, provider: forge, issueUrl: task.issueUrl })
   if (issue === undefined || issue === null) return { error: 'issue-not-found', status: 404 }
   return { task: store.updateTask(id, refreshPatch(task, issue)) }
 }
@@ -199,7 +200,7 @@ export async function searchRepos({ gitea, query, limit = 20 }) {
  * Failure midway avoids leaving orphaned cards.
  */
 export async function createProjectTask({
-  gitea, store, owner, repo, newRepo, title, body, board = 'main',
+  gitea, store, owner, repo, newRepo, title, body, board = 'main', provider, forge,
 }) {
   const state = await giteaState(gitea)
   if (state !== 'ready') return { error: `gitea-${state}`, status: 409 }
@@ -214,7 +215,7 @@ export async function createProjectTask({
     // Validate repository name before API call.
     if (safeSegment(wanted) === undefined) return { error: 'bad-repo-name', status: 400 }
     try {
-      await gitea.createRepo({ owner, name: wanted })
+      await gitea.createRepo({ owner, name: wanted, provider: forge || provider })
     } catch (error) {
       return { error: 'repo-not-created', status: 502, detail: String(error?.message ?? error) }
     }
@@ -223,11 +224,11 @@ export async function createProjectTask({
 
   let issue
   try {
-    issue = await gitea.createIssue({ owner, repo: targetRepo, title: name, body })
+    issue = await gitea.createIssue({ owner, repo: targetRepo, title: name, body, provider: forge || provider })
   } catch (error) {
     // Repository may have already been created; avoid deleting on issue creation failure.
     return { error: 'issue-not-created', status: 502, detail: String(error?.message ?? error) }
   }
 
-  return { task: store.createTask(issueToTask(issue, { board, column: 'backlog', owner, repo: targetRepo })) }
+  return { task: store.createTask(issueToTask(issue, { board, column: 'backlog', owner, repo: targetRepo, forge: forge || provider })) }
 }

package/lib/index.js

@@ -807,14 +807,14 @@ export function apply(ctx, config) {
     // Single setting switch controls both board tools.
     const registerBoardTool = () => {
       const off = [
-        ctx.tools.register(defineTool(boardMoveDefinition({ store, config: getConfig }))),
-        ctx.tools.register(defineTool(boardPlanDefinition({ store }))),
-        ctx.tools.register(defineTool(boardChecklistDefinition({ store }))),
+        ctx.tools.register(defineTool(boardMoveDefinition({ store, config: getConfig, eventHub }))),
+        ctx.tools.register(defineTool(boardPlanDefinition({ store, eventHub }))),
+        ctx.tools.register(defineTool(boardChecklistDefinition({ store, eventHub }))),
         ctx.tools.register(defineTool(boardReportDefinition({ store }))),
         ctx.tools.register(defineTool(boardCommentsDefinition({ store }))),
         ctx.tools.register(defineTool(boardCommentAddDefinition({ store }))),
         ctx.tools.register(defineTool(boardDecomposeDefinition({ store, gitea: git }))),
-        ctx.tools.register(defineTool(boardChecklistItemDefinition({ store }))),
+        ctx.tools.register(defineTool(boardChecklistItemDefinition({ store, eventHub }))),
       ]
       return () => { for (const stop of off) stop?.() }
     }
@@ -946,7 +946,11 @@ export function apply(ctx, config) {
       if (!isTrustedRequest(req)) { writeJson(res, 403, { error: 'cross-site' }); return }
       try {
         const input = await readBody(req)
-        reply(res, importBoard({ store, input }))
+        const impResult = importBoard({ store, input })
+        if (impResult?.imported > 0) {
+          eventHub.broadcast('task:change', { action: 'imported', count: impResult.imported })
+        }
+        reply(res, impResult)
       } catch {
         writeJson(res, 400, { error: 'bad-request' })
       }
@@ -965,7 +969,11 @@ export function apply(ctx, config) {
         if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
         if (!isTrustedRequest(req)) { writeJson(res, 403, { error: 'cross-site' }); return }
         try {
-          reply(res, createTask({ store, input: await readBody(req) }))
+          const resObj = createTask({ store, input: await readBody(req) })
+          if (resObj?.task) {
+            eventHub.broadcast('task:change', { taskId: resObj.task.id, action: 'created' })
+          }
+          reply(res, resObj)
         } catch (error) {
           writeJson(res, error?.status ?? 500, { error: 'bad-request' })
         }
@@ -987,12 +995,23 @@ export function apply(ctx, config) {
         return
       }
       if (!isTrustedRequest(req)) { writeJson(res, 403, { error: 'cross-site' }); return }
-      if (req.method === 'DELETE' && action === undefined) { reply(res, deleteTask({ store, id })); return }
+      if (req.method === 'DELETE' && action === undefined) {
+        const resObj = deleteTask({ store, id })
+        if (resObj?.deleted) {
+          eventHub.broadcast('task:change', { taskId: id, action: 'deleted' })
+        }
+        reply(res, resObj)
+        return
+      }
       // Card fields update: title, body, labels, priority. Priority is board-local.
       if (req.method === 'POST' && action === 'update') {
         try {
           const input = await readBody(req)
-          reply(res, updateTask({ store, id, input }))
+          const resObj = updateTask({ store, id, input })
+          if (resObj?.task) {
+            eventHub.broadcast('task:change', { taskId: id, action: 'updated' })
+          }
+          reply(res, resObj)
         } catch {
           writeJson(res, 400, { error: 'bad-request' })
         }
@@ -1169,6 +1188,9 @@ export function apply(ctx, config) {
         }
         if (req.method === 'POST' && action === 'checklist-toggle') {
           const resObj = handleToggleChecklistItem({ store, task: store.getTask(id), input })
+          if (resObj?.body?.task) {
+            eventHub.broadcast('task:change', { taskId: id, action: 'updated' })
+          }
           writeJson(res, resObj.status, resObj.body)
           return
         }
@@ -1179,6 +1201,9 @@ export function apply(ctx, config) {
         }
         if (req.method === 'POST' && action === 'checklist') {
           const resObj = handleTaskChecklist({ store, task: store.getTask(id), input })
+          if (resObj?.body?.task) {
+            eventHub.broadcast('task:change', { taskId: id, action: 'updated' })
+          }
           writeJson(res, resObj.status, resObj.body)
           return
         }

package/lib/launcher.js

@@ -12,11 +12,38 @@
 
 import { isAbsolute, join, resolve, sep } from 'node:path'
 import { randomUUID } from 'node:crypto'
-import { createTaskWorktree, registerDshWorkspace } from './worktree.js'
+import { createTaskWorktree, registerDshWorkspace, isGitRepo } from './worktree.js'
 import { formatHandoverPreamble, parseProgressDump } from './progress-dump.js'
 
 export const PERMISSION_RANKS = { 'read-only': 0, 'workspace-write': 1, 'danger-full-access': 2 }
 
+const activeReservations = new Set()
+
+export function reserveSessionSlot(taskId) {
+  if (taskId) activeReservations.add(taskId)
+}
+
+export function releaseSessionSlot(taskId) {
+  if (taskId) activeReservations.delete(taskId)
+}
+
+export function verifyPermissionGate({ task, permission, config }) {
+  if (!config?.permissionGateEnabled) return
+  const perm = permission || task?.permission || config?.sessionDefaultPermission || 'read-only'
+  const defaultPerm = config?.sessionDefaultPermission || 'read-only'
+  const permRank = PERMISSION_RANKS[perm] ?? Infinity
+  const defaultRank = PERMISSION_RANKS[defaultPerm] ?? 0
+  const confirmedTier = task?.permissionConfirmedTier || (task?.permissionConfirmedAt ? task?.permission : undefined)
+  const confirmedRank = confirmedTier ? (PERMISSION_RANKS[confirmedTier] ?? -1) : -1
+
+  if (permRank > defaultRank && permRank > confirmedRank) {
+    const err = new Error('Permission confirmation required')
+    err.key = 'permission-unconfirmed'
+    err.status = 403
+    throw err
+  }
+}
+
 /**
  * Tail instructions for local board tasks.
  *
@@ -134,20 +161,44 @@ export function applyPermission({ permissions, agent, name }) {
 export async function obtainAgent({
   agents, task, config, provider, model, mintSessionId, cwdOf, logger,
   agentPreset, permission, permissions, gitRunner, workspaceRegistry,
+  reasoningEffort,
 }) {
+  const chosenPerm = permission || task?.permission || ''
+  const effort = reasoningEffort || task?.reasoningEffort || undefined
+  const agentOptions = { provider, model, ...(effort ? { reasoningEffort: effort } : {}) }
+
   const known = typeof task?.sessionId === 'string' && task.sessionId !== '' ? task.sessionId : undefined
 
   if (known !== undefined) {
     // Live agent — reuse active session.
     let live
     try { live = agents.get(known) } catch { live = undefined }
-    if (live !== undefined) return { agent: live, sessionId: known, mode: 'opened' }
+    if (live !== undefined) {
+      const access = applyPermission({ permissions, agent: live, name: chosenPerm })
+      if (access.error !== undefined) {
+        const error = new Error('access tier not set')
+        error.key = access.error
+        error.status = 409
+        throw error
+      }
+      return { agent: live, sessionId: known, mode: 'opened' }
+    }
 
     // Session suspended; attempt resume.
     try {
-      const handle = await agents.resume({ resumeSessionId: known, agentOptions: { provider, model } })
+      const handle = await agents.resume({ resumeSessionId: known, agentOptions })
+      const access = applyPermission({ permissions, agent: handle.agent, name: chosenPerm })
+      if (access.error !== undefined) {
+        const error = new Error('access tier not set')
+        error.key = access.error
+        error.status = 409
+        throw error
+      }
       return { agent: handle.agent, sessionId: handle.agent.session.id, mode: 'resumed' }
     } catch (error) {
+      if (error?.key === 'permission-refused' || error?.key === 'permission-unavailable' || error?.status === 409) {
+        throw error
+      }
       logger?.warn?.(`dsh-kanban: session ${known} resume failed: ${error?.message}`)
     }
   }
@@ -159,30 +210,41 @@ export async function obtainAgent({
   let workspaceId = task?.workspaceId || undefined
   let worktreeCreated = false
 
-  if (config?.worktreeIsolation !== false && task?.repo) {
+  const isGit = await isGitRepo(cwd, gitRunner)
+  if (config?.worktreeIsolation !== false && isGit) {
+    let created
     try {
-      const created = await createTaskWorktree({
+      created = await createTaskWorktree({
         task,
         repoDir: cwd,
         config,
         gitRunner,
         cwdOf,
       })
-      if (created) {
-        worktreePath = created.worktreePath
-        branchName = created.branchName
-        worktreeCreated = created.created === true
-
-        if (workspaceRegistry) {
-          workspaceId = await registerDshWorkspace({
-            workspaceRegistry,
-            worktreePath,
-            title: `${task.owner ? task.owner + '/' : ''}${task.repo}#${task.issueNumber || task.id.slice(0, 8)}: ${task.title}`,
-          })
-        }
-      }
     } catch (err) {
-      logger?.warn?.(`dsh-kanban: failed to create worktree for ${task.id}: ${err.message}`)
+      const error = new Error(`worktree-creation-failed: ${err.message}`)
+      error.key = 'worktree-creation-failed'
+      error.status = 500
+      throw error
+    }
+
+    if (!created?.worktreePath) {
+      const error = new Error('worktree-creation-failed')
+      error.key = 'worktree-creation-failed'
+      error.status = 500
+      throw error
+    }
+
+    worktreePath = created.worktreePath
+    branchName = created.branchName
+    worktreeCreated = created.created === true
+
+    if (workspaceRegistry) {
+      workspaceId = await registerDshWorkspace({
+        workspaceRegistry,
+        worktreePath,
+        title: `${task.owner ? task.owner + '/' : ''}${task.repo}#${task.issueNumber || task.id.slice(0, 8)}: ${task.title}`,
+      })
     }
   }
 
@@ -197,9 +259,9 @@ export async function obtainAgent({
     sessionId: mintSessionId(),
     // Profile is set during session creation.
     meta,
-    agentOptions: { provider, model },
+    agentOptions,
   })
-  const access = applyPermission({ permissions, agent: handle.agent, name: permission })
+  const access = applyPermission({ permissions, agent: handle.agent, name: chosenPerm })
   if (access.error !== undefined) {
     // Session already initialized; preserve configured permissions.
     try { handle.dispose?.() } catch { /* cleanup is secondary to rejection */ }
@@ -265,9 +327,11 @@ export async function runTask({
   agents, store, task, config, provider, model,
   mintSessionId, createMessage, cwdOf, logger, text,
   agentPreset, permission, permissions, claimAs,
-  gitRunner, workspaceRegistry, resume = false,
+  gitRunner, workspaceRegistry, resume = false, reasoningEffort,
 }) {
-  // Concurrency limit check (#214)
+  const effort = reasoningEffort || task?.reasoningEffort || undefined
+
+  // Concurrency limit check (#214, #330)
   const maxConcurrent = typeof config?.maxConcurrentSessions === 'number' ? config.maxConcurrentSessions : 3
   if (maxConcurrent > 0) {
     const activeCount = countActiveSessions({ store, agents })
@@ -275,7 +339,16 @@ export async function runTask({
     const isAlreadyRunning = task.sessionId && agents?.get?.(task.sessionId)?.status === 'running'
     if (!isAlreadyRunning && activeCount >= maxConcurrent) {
       const now = Date.now()
-      store.updateTask(task.id, { queuedAt: task.queuedAt > 0 ? task.queuedAt : now })
+      store.updateTask(task.id, {
+        queuedAt: task.queuedAt > 0 ? task.queuedAt : now,
+        ...(provider ? { provider } : {}),
+        ...(model ? { model } : {}),
+        ...(permission ? { permission } : {}),
+        ...(effort ? { reasoningEffort: effort } : {}),
+        queuedRequest: JSON.stringify({
+          provider, model, permission, reasoningEffort: effort, agentPreset, text,
+        }),
+      })
       store.addTransition({
         taskId: task.id,
         fromCol: task.column,
@@ -286,28 +359,23 @@ export async function runTask({
       return { mode: 'queued', queued: true, taskId: task.id, activeCount, maxConcurrent }
     }
   }
-  if (config?.permissionGateEnabled) {
-    const perm = permission || task.permission || 'read-only'
-    const defaultPerm = config?.sessionDefaultPermission || 'read-only'
-    const permRank = PERMISSION_RANKS[perm] ?? Infinity
-    const defaultRank = PERMISSION_RANKS[defaultPerm] ?? 0
-    if (permRank > defaultRank) {
-      if (!task.permissionConfirmedAt || task.permissionConfirmedAt === 0) {
-        const err = new Error('Permission confirmation required')
-        err.key = 'permission-unconfirmed'
-        err.status = 403
-        throw err
-      }
-    }
-  }
 
-  const taken = await obtainAgent({
-    agents, task, config, provider, model, mintSessionId, cwdOf, logger,
-    agentPreset, permission, permissions, gitRunner, workspaceRegistry,
-  })
+  verifyPermissionGate({ task, permission, config })
 
-  if (task.queuedAt > 0) {
-    store.updateTask(task.id, { queuedAt: 0 })
+  reserveSessionSlot(task.id)
+  let taken
+  try {
+    taken = await obtainAgent({
+      agents, task, config, provider, model, mintSessionId, cwdOf, logger,
+      agentPreset, permission, permissions, gitRunner, workspaceRegistry,
+      reasoningEffort: effort,
+    })
+  } finally {
+    releaseSessionSlot(task.id)
+  }
+
+  if (task.queuedAt > 0 || task.queuedRequest) {
+    store.updateTask(task.id, { queuedAt: 0, queuedRequest: '' })
   }
 
   // Record run in task execution history
@@ -462,10 +530,31 @@ export async function runBatch({
   const list = (tasks ?? []).filter((task) => task !== undefined)
   if (list.length === 0) return { error: 'nothing-picked', status: 400 }
 
-  const taken = await obtainAgent({
-    agents, task: list[0], config, provider, model, mintSessionId, cwdOf, logger,
-    agentPreset, permission, permissions,
-  })
+  for (const t of list) {
+    verifyPermissionGate({ task: t, permission, config })
+  }
+
+  const maxConcurrent = typeof config?.maxConcurrentSessions === 'number' ? config.maxConcurrentSessions : 3
+  if (maxConcurrent > 0) {
+    const activeCount = countActiveSessions({ store, agents })
+    if (activeCount >= maxConcurrent) {
+      const err = new Error('concurrent-limit-reached')
+      err.key = 'concurrent-limit-reached'
+      err.status = 429
+      throw err
+    }
+  }
+
+  reserveSessionSlot(list[0].id)
+  let taken
+  try {
+    taken = await obtainAgent({
+      agents, task: list[0], config, provider, model, mintSessionId, cwdOf, logger,
+      agentPreset, permission, permissions,
+    })
+  } finally {
+    releaseSessionSlot(list[0].id)
+  }
 
   await taken.agent.whenIdle()
   const own = typeof text === 'string' ? text.trim() : ''
@@ -563,12 +652,23 @@ export function unqueueTask({ store, task }) {
  */
 export function countActiveSessions({ store, agents }) {
   const sessions = liveSessions({ store, agents })
-  return sessions.filter((s) => s.status === 'running' || s.status === 'busy' || s.status === 'thinking').length
+  const activeCount = sessions.filter((s) => s.status === 'running' || s.status === 'busy' || s.status === 'thinking').length
+  return activeCount + activeReservations.size
 }
 
 export function liveSessions({ store, agents }) {
   const byId = new Map()
-  const all = [...store.listTasks({ board: 'main' }), ...store.listTasks({ board: 'simple' })]
+  let all = []
+  if (typeof store?.listBoards === 'function' && typeof store?.listTasks === 'function') {
+    const boards = store.listBoards() || []
+    all = boards.flatMap((b) => store.listTasks({ board: b.id }) || [])
+  } else if (typeof store?.listTasks === 'function') {
+    all = store.listTasks() || []
+  } else if (typeof store?.listInColumn === 'function') {
+    all = store.listInColumn('in-progress') || []
+  } else if (Array.isArray(store?.tasks)) {
+    all = store.tasks
+  }
   for (const task of all) {
     const id = typeof task.sessionId === 'string' ? task.sessionId : ''
     if (id === '') continue
@@ -606,19 +706,26 @@ export async function dispatchNextQueuedTask({
   if (queued.length === 0) return null
 
   const nextTask = queued[0]
+  let queuedParams = {}
+  if (typeof nextTask.queuedRequest === 'string' && nextTask.queuedRequest) {
+    try { queuedParams = JSON.parse(nextTask.queuedRequest) } catch { /* ignore */ }
+  }
   try {
     return await runTask({
       agents,
       store,
       task: nextTask,
       config,
-      provider: nextTask.provider || undefined,
-      model: nextTask.model || undefined,
+      provider: queuedParams.provider || nextTask.provider || undefined,
+      model: queuedParams.model || nextTask.model || undefined,
+      permission: queuedParams.permission || nextTask.permission || undefined,
+      reasoningEffort: queuedParams.reasoningEffort || nextTask.reasoningEffort || undefined,
+      text: queuedParams.text || undefined,
+      agentPreset: queuedParams.agentPreset || agentPreset,
       mintSessionId: mintSessionId || (() => `kanban-${nextTask.id}-${randomUUID()}`),
       createMessage: createMessage || ((msg) => msg),
       cwdOf,
       logger,
-      agentPreset,
       permissions,
       workspaceRegistry,
       claimAs: claimAs || 'queue-dispatcher',

package/lib/order.js

@@ -1,63 +1,33 @@
 // Fractional ordering index for cards.
 //
-// Naive approach stores integer index, and dragging card to the top of column
-// with ten items requires rewriting all ten. Here order is stored as string,
-// and new value is generated BETWEEN two neighbors, so drag-and-drop is always
-// a single UPDATE of one row regardless of how many cards are in column.
-//
-// String-based implementation is intentional. Floating-point numbers fail
-// after ~50 insertions into the same position when precision runs out.
-//
-// Key is read as fraction after implicit '0.': comparison is standard
-// lexicographical. Key never ends with first alphabet character to ensure
-// subsequent division remains possible.
-
-/** Alphabet in ascending character code order. */
-const DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz'
-const FIRST = DIGITS[0]
-
-/** Value strictly between `a` and `b`; `b === undefined` means unbounded right. */
-function midpoint(a, b) {
-  if (b !== undefined && a >= b) {
-    throw new Error(`order violated: ${JSON.stringify(a)} not less than ${JSON.stringify(b)}`)
-  }
-  if (a.endsWith(FIRST) || (b !== undefined && b.endsWith(FIRST))) {
-    throw new Error('order key cannot end with first alphabet symbol')
-  }
-
-  if (b !== undefined) {
-    // Common prefix carried as-is, division continues on remainder
-    // to avoid inflating key length unnecessarily.
-    let n = 0
-    while ((a[n] ?? FIRST) === b[n]) n += 1
-    if (n > 0) return b.slice(0, n) + midpoint(a.slice(n), b.slice(n))
-  }
-
-  const from = a === '' ? 0 : DIGITS.indexOf(a[0])
-  const to = b === undefined ? DIGITS.length : DIGITS.indexOf(b[0])
-  if (from < 0 || to < 0) throw new Error('order key contains character outside alphabet')
+// String-based implementation using rocicorp/fractional-indexing (CC0-1.0).
+// Generates bounded-length order keys strictly between neighbors, avoiding
+// O(N^2) string inflation on repeated appends/prepends.
 
-  if (to - from > 1) {
-    return DIGITS[Math.round(0.5 * (from + to))]
-  }
-  if (b !== undefined && b.length > 1) {
-    return b.slice(0, 1)
-  }
-  // Adjacent symbols: take `a` digit and divide next position.
-  return DIGITS[from] + midpoint(a.slice(1), undefined)
-}
+import { generateKeyBetween, generateNKeysBetween } from './fractional-indexing.js'
 
 /**
  * Fractional order key strictly between two neighbors.
  *
- * Both neighbors are optional: without either returns default initial value;
- * without right returns value after `a`; without left returns value before `b`.
- *
  * @param {string} [a] left neighbor order key
  * @param {string} [b] right neighbor order key
  * @returns {string} key strictly between them
- * @throws if `a` is not less than `b` or key contains invalid character
+ * @throws if a >= b or key contains invalid character
  */
 export function keyBetween(a, b) {
-  return midpoint(a ?? '', b ?? undefined)
+  if (a !== undefined && a !== null && b !== undefined && b !== null) {
+    if (a >= b) {
+      throw new Error(`order violated: ${JSON.stringify(a)} not less than ${JSON.stringify(b)}`)
+    }
+  }
+  if (typeof a === 'string' && /[^0-9a-zA-Z]/.test(a)) {
+    throw new Error('order key contains character outside alphabet')
+  }
+  if (typeof b === 'string' && /[^0-9a-zA-Z]/.test(b)) {
+    throw new Error('order key contains character outside alphabet')
+  }
+
+  return generateKeyBetween(a ?? null, b ?? null)
 }
+
+export { generateKeyBetween, generateNKeysBetween }