refactor: ablate redundant abstractions across packages (#352)

Author: antfubot

alias.ts

@@ -74,10 +74,8 @@ export const alias = {
   '@devframes/json-render/hub': r('json-render/src/hub.ts'),
   '@devframes/json-render/node': r('json-render/src/node/index.ts'),
   '@devframes/json-render': r('json-render/src/index.ts'),
-  '@devframes/json-render-ui/components': r('json-render-ui/src/components/index.ts'),
   '@devframes/json-render-ui/hub': r('json-render-ui/src/hub.ts'),
   '@devframes/json-render-ui/spa': r('json-render-ui/src/spa.ts'),
-  '@devframes/json-render-ui': r('json-render-ui/src/index.ts'),
   'json-render/dashboard': fileURLToPath(new URL('./examples/json-render/src/node/dashboard.ts', import.meta.url)),
   '@devframes/plugin-code-server/node': p('code-server/src/node/setup.ts'),
   '@devframes/plugin-code-server/constants': p('code-server/src/node/constants.ts'),

knip.jsonc

@@ -180,9 +180,8 @@
       // Published node-safe entries are `spa.ts`/`hub.ts`; the browser
       // renderer ships only as self-contained Vite bundles (the standalone
       // SPA and the prebuilt renderer module, consumed at runtime via the
-      // hub's renderer manifest). `src/index.ts` stays as the source barrel
-      // those Vite/Storybook builds resolve, so it's declared as an entry too.
-      "entry": ["src/{index,spa,hub}.ts", "src/renderer-module/index.ts"],
+      // hub's renderer manifest).
+      "entry": ["src/{spa,hub}.ts", "src/renderer-module/index.ts"],
       // The standalone SPA's own Vite config (`src/spa/vite.config.ts`)
       // mounts `unocss/vite` with no explicit config path, so UnoCSS
       // discovers this nested `uno.config.ts` by directory proximity to

packages/devframe/src/adapters/mcp/__tests__/to-json-schema.test.ts

@@ -22,18 +22,17 @@ function withJsonSchema(json: Record<string, unknown>): StandardSchemaV1 {
 
 describe('argsToJsonSchema', () => {
   it('returns an empty object schema when no args', () => {
-    const { schema, unwrapped } = argsToJsonSchema(undefined)
-    expect(unwrapped).toBe(false)
+    const schema = argsToJsonSchema(undefined)
     expect(schema).toEqual({ type: 'object', properties: {} })
   })
 
   it('uses the schema\'s own Standard JSON Schema converter when present', () => {
-    const { schema } = argsToJsonSchema([withJsonSchema({ type: 'string' })])
+    const schema = argsToJsonSchema([withJsonSchema({ type: 'string' })])
     expect((schema as any).properties.arg0).toEqual({ type: 'string' })
   })
 
   it('falls back to a permissive object for validators without a native converter (valibot)', () => {
-    const { schema } = argsToJsonSchema([v.string(), v.number()])
+    const schema = argsToJsonSchema([v.string(), v.number()])
     expect((schema as any).properties.arg0).toEqual(PERMISSIVE)
     expect((schema as any).properties.arg1).toEqual(PERMISSIVE)
     expect(schema).toMatchObject({ type: 'object', required: ['arg0', 'arg1'], additionalProperties: false })

packages/devframe/src/adapters/mcp/build-server.ts

@@ -428,14 +428,14 @@ function projectTool(name: string, tool: AgentTool, ctx: DevframeNodeContext): T
 
 function computeInputSchema(tool: AgentTool, ctx: DevframeNodeContext): unknown {
   if (tool.kind === 'tool')
-    return argsToJsonSchema(tool.args).schema
+    return argsToJsonSchema(tool.args)
   if (tool.kind !== 'rpc' || !tool.rpcName)
     return { type: 'object', properties: {} }
   const def = ctx.rpc.definitions.get(tool.rpcName) as RpcFunctionDefinitionAnyWithContext<DevframeNodeContext> | undefined
   if (!def)
     return { type: 'object', properties: {} }
   const args = def.args as readonly StandardSchemaV1[] | undefined
-  return argsToJsonSchema(args).schema
+  return argsToJsonSchema(args)
 }
 
 function computeOutputSchema(tool: AgentTool, ctx: DevframeNodeContext): unknown {

packages/devframe/src/adapters/mcp/to-json-schema.ts

@@ -48,9 +48,9 @@ export function returnToJsonSchema(schema: StandardSchemaV1 | undefined): unknow
  */
 export function argsToJsonSchema(
   args: readonly StandardSchemaV1[] | undefined,
-): { schema: unknown, unwrapped: boolean } {
+): unknown {
   if (!args || args.length === 0)
-    return { schema: { type: 'object', properties: {} }, unwrapped: false }
+    return { type: 'object', properties: {} }
 
   const properties: Record<string, unknown> = {}
   const required: string[] = []
@@ -61,12 +61,9 @@ export function argsToJsonSchema(
   }
 
   return {
-    schema: {
-      type: 'object',
-      properties,
-      required,
-      additionalProperties: false,
-    },
-    unwrapped: false,
+    type: 'object',
+    properties,
+    required,
+    additionalProperties: false,
   }
 }

packages/devframe/src/client/rpc-live.ts

@@ -4,7 +4,6 @@ import type { DevframeConnectionStatus } from './connection'
 import type { DevframeClientRpcHost, DevframeRpcClientMode, DevframeRpcClientOptions, RpcClientEvents } from './rpc'
 import { createRpcClient } from 'devframe/rpc/client'
 import { DEVFRAME_EVENTS } from '../events'
-import { promiseWithResolver } from '../utils/promise'
 import { DevframeConnectionError } from './connection'
 
 /** What a live transport's channel factory receives from the shared mode. */
@@ -53,7 +52,7 @@ export function createLiveRpcClientMode(
   let isTrusted = false
   let status: DevframeConnectionStatus = 'connecting'
   let connectionError: Error | null = null
-  const trustedPromise = promiseWithResolver<boolean>()
+  const trustedPromise = Promise.withResolvers<boolean>()
 
   // ── connection status ────────────────────────────────────────────────────
 

packages/devframe/src/client/settings.ts

@@ -1,6 +1,7 @@
 import type { DevframeSettings, DevframeSettingsStore } from 'devframe/types'
 import type { SharedState } from 'devframe/utils/shared-state'
 import type { DevframeRpcClient } from './rpc'
+import { createSettingsStore } from '../settings-store'
 
 function createClientSettingsStore<T extends Record<string, any>>(
   rpc: DevframeRpcClient,
@@ -21,27 +22,7 @@ function createClientSettingsStore<T extends Record<string, any>>(
     return statePromise
   }
 
-  return {
-    async get(key) {
-      return ((await store()).value() as T)[key]
-    },
-    async set(key, value) {
-      ;(await store()).mutate((draft) => {
-        ;(draft as T)[key] = value
-      })
-    },
-    async delete(key) {
-      ;(await store()).mutate((draft) => {
-        delete (draft as T)[key]
-      })
-    },
-    async all() {
-      return (await store()).value() as Readonly<T>
-    },
-    async onChange(fn) {
-      return (await store()).on('updated', full => fn(full as Readonly<T>))
-    },
-  }
+  return createSettingsStore<T>(store)
 }
 
 /**

packages/devframe/src/node/settings.ts

@@ -1,6 +1,7 @@
 import type { DevframeNodeContext, DevframeRpcSharedStates, DevframeSettings, DevframeSettingsStore } from 'devframe/types'
 import type { SharedState } from 'devframe/utils/shared-state'
 import { join } from 'pathe'
+import { createSettingsStore } from '../settings-store'
 import { createStorage } from './storage'
 
 // Map a settings scope to the host storage scope it persists under.
@@ -32,27 +33,7 @@ function createNodeSettingsStore<T extends Record<string, any>>(
     return statePromise
   }
 
-  return {
-    async get(key) {
-      return ((await store()).value() as T)[key]
-    },
-    async set(key, value) {
-      ;(await store()).mutate((draft) => {
-        ;(draft as T)[key] = value
-      })
-    },
-    async delete(key) {
-      ;(await store()).mutate((draft) => {
-        delete (draft as T)[key]
-      })
-    },
-    async all() {
-      return (await store()).value() as Readonly<T>
-    },
-    async onChange(fn) {
-      return (await store()).on('updated', full => fn(full as Readonly<T>))
-    },
-  }
+  return createSettingsStore<T>(store)
 }
 
 /**

packages/devframe/src/rpc/types.test.ts

@@ -4,11 +4,15 @@ import type {
   RpcDefinitionsToFunctions,
   RpcFunctionDefinitionToFunction,
 } from '.'
-import type { AssertEqual } from './utils'
 import * as v from 'valibot'
 import { describe, it } from 'vitest'
 import { defineRpcFunction } from '.'
 
+/** Type-level assertion that two types are equal. */
+type AssertEqual<X, Y>
+  = (<T>() => T extends X ? 1 : 2) extends
+  (<T>() => T extends Y ? 1 : 2) ? true : never
+
 /** Fake a typed Standard Schema from a non-valibot vendor. */
 function schema<Input, Output = Input>(): StandardSchemaV1<Input, Output> {
   return {

packages/devframe/src/rpc/utils.ts

@@ -1,11 +1,6 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { RpcArgsSchema, RpcReturnSchema } from './types'
 
-/** Type-level assertion that two types are equal */
-export type AssertEqual<X, Y>
-  = (<T>() => T extends X ? 1 : 2) extends
-  (<T>() => T extends Y ? 1 : 2) ? true : never
-
 /** Infers a TypeScript argument tuple from a Standard Schema array */
 export type InferArgsType<S extends RpcArgsSchema | undefined>
   = S extends readonly [] ? []