refactor(deps): drop onlyBundle; resolve schema/diagnostics types via devframe peer

tsdown's default deps/devDeps split already expresses bundle intent
(dependencies external, devDependencies bundled), so the onlyBundle
whitelists in devframe/hub/json-render are removed.

devframe re-exports the Standard Schema contract type from
devframe/utils/simple-schema and adds a DevframeDiagnostics helper type to
devframe/utils/nostics. @devframes/json-render now names both through the
devframe peer instead of inlining nostics or depending on
@standard-schema/spec: its public dts references devframe/utils/simple-schema
and devframe/utils/nostics, and @standard-schema/spec is dropped from its
package.json. Any integration can reuse both the same way.

Author: antfubot

packages/devframe/src/utils/nostics.ts

@@ -41,13 +41,26 @@ export function defineDiagnostics<
   docsBase?: string | ((code: keyof Codes) => string | undefined)
   codes: Codes
   reporters?: Reporters
-}): Diagnostics<Codes, readonly [typeof devframeReporter, ...Reporters]> {
+}): DevframeDiagnostics<Codes, Reporters> {
   return defineNosticsDiagnostics({
     ...options,
     reporters: [devframeReporter, ...(options.reporters ?? [])],
-  }) as Diagnostics<Codes, readonly [typeof devframeReporter, ...Reporters]>
+  }) as DevframeDiagnostics<Codes, Reporters>
 }
 
+/**
+ * The `Diagnostics` object returned by devframe's {@link defineDiagnostics}
+ * (devframe's ANSI console reporter is always prepended). Integrations that
+ * export their own `defineDiagnostics(...)` result as public API annotate it
+ * with this type, so the reference resolves through `devframe/utils/nostics`
+ * rather than inlining `nostics`'s types or taking a direct `nostics`
+ * dependency.
+ */
+export type DevframeDiagnostics<
+  Codes extends Record<string, DiagnosticDefinition>,
+  Reporters extends readonly AnyDiagnosticReporter[] = [],
+> = Diagnostics<Codes, readonly [typeof devframeReporter, ...Reporters]>
+
 export {
   createConsoleReporter,
   defineProdDiagnostics,

packages/devframe/src/utils/simple-schema.ts

@@ -1,5 +1,13 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 
+/**
+ * Re-exported [Standard Schema](https://standardschema.dev/) contract types so
+ * integrations can type `args`/`returns`/view schemas against Standard Schema
+ * through the devframe peer, without taking their own `@standard-schema/spec`
+ * dependency (devframe inlines the declarations into its own `.d.mts`).
+ */
+export type { StandardSchemaV1 } from '@standard-schema/spec'
+
 /**
  * A tiny, zero-dependency [Standard Schema](https://standardschema.dev/)
  * builder.

packages/devframe/tsdown.config.ts

@@ -26,7 +26,7 @@ const deps = {
     '@jridgewell/trace-mapping',
   ],
   /**
-   * `whenexpr` is runtime-only bundled (see `onlyBundle` below); its
+   * `whenexpr` is a devDependency, so its runtime is bundled in; its
    * declaration file mixes type-only and value named exports
    * (`export { type WhenExpression, evaluateWhen, ... }`) in a way that
    * trips up rolldown's dts bundler when it tries to inline the type
@@ -38,27 +38,6 @@ const deps = {
   dts: {
     neverBundle: ['whenexpr'],
   },
-  onlyBundle: [
-    '@standard-schema/spec',
-    'acorn',
-    'birpc',
-    'get-port-please',
-    'immer',
-    'launch-editor',
-    'mlly',
-    'mrmime',
-    'obug',
-    'ohash',
-    'p-limit',
-    'perfect-debounce',
-    'picocolors',
-    'shell-quote',
-    'structured-clone-es',
-    'tinyexec',
-    'ua-parser-modern',
-    'whenexpr',
-    'yocto-queue',
-  ],
 }
 
 // The node build reaches `devframe/utils/shared-state` through the same

packages/hub/tsdown.config.ts

@@ -22,10 +22,5 @@ export default defineConfig({
       'postcss',
       'rolldown',
     ],
-    onlyBundle: [
-      '@standard-schema/spec',
-      'acorn',
-      'get-port-please',
-    ],
   },
 })

packages/json-render/package.json

@@ -50,7 +50,6 @@
   },
   "devDependencies": {
     "@devframes/hub": "workspace:*",
-    "@standard-schema/spec": "catalog:deps",
     "@types/node": "catalog:types",
     "devframe": "workspace:*",
     "tsdown": "catalog:build"

packages/json-render/src/node/create-view.ts

@@ -1,6 +1,6 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { DevframeNodeContext, DevframeScopedNodeContext } from 'devframe'
 import type { SharedState, SharedStatePatch } from 'devframe/utils/shared-state'
+import type { StandardSchemaV1 } from 'devframe/utils/simple-schema'
 import type { DevframeJsonRenderSpec, JsonRenderStatePatch, JsonRenderView } from '../types'
 import type { JsonRenderIndex } from '../view-index'
 import { createSharedState } from 'devframe/utils/shared-state'

packages/json-render/src/node/diagnostics.ts

@@ -1,42 +1,48 @@
+import type { DevframeDiagnostics } from 'devframe/utils/nostics'
 import { defineDiagnostics } from 'devframe/utils/nostics'
 
+const codes = {
+  DF0038: {
+    why: (p: { id: string, key: string, issues: string }) =>
+      `JSON-render view "${p.id}" received invalid props on element "${p.key}": ${p.issues}`,
+    fix: 'Match the element props to the base catalog\'s prop schema for that component. See the component reference for the expected shape.',
+  },
+  DF0039: {
+    why: (p: { id: string, scope: string }) =>
+      `A JSON-render view with id "${p.id}" already exists in scope "${p.scope}".`,
+    fix: 'Give each view a stable id unique within its scope, or dispose the previous view before recreating it.',
+  },
+  DF0040: {
+    why: (p: { id: string }) =>
+      `JSON-render view "${p.id}" was used after it was disposed.`,
+    fix: 'Create a fresh view with `createJsonRenderView` instead of reusing a disposed handle.',
+  },
+  DF0041: {
+    why: (p: { id: string, reason: string }) =>
+      `JSON-render view "${p.id}" spec is not JSON-serializable: ${p.reason}`,
+    fix: 'Specs and state travel as strict JSON, so remove functions, symbols, class instances, Map/Set, or circular references.',
+  },
+  DF0073: {
+    why: (p: { id: string, issues: string }) =>
+      `JSON-render view "${p.id}" does not match its configured schema: ${p.issues}`,
+    fix: 'Match the authored spec to the Standard Schema passed to `createJsonRenderView`.',
+  },
+  DF0074: {
+    why: (p: { id: string }) =>
+      `JSON-render view "${p.id}" uses an asynchronous Standard Schema.`,
+    fix: 'Use a synchronous Standard Schema so initial creation and updates remain synchronous.',
+  },
+}
+
 /**
  * `@devframes/json-render` protocol/runtime diagnostics share the `DF`
  * prefix and use the next globally available core codes. Browser-only render
  * failures keep `console.*` in the UI package.
+ *
+ * Annotated with {@link DevframeDiagnostics} so the public type resolves
+ * through the `devframe/utils/nostics` peer rather than inlining `nostics`.
  */
-export const diagnostics = defineDiagnostics({
+export const diagnostics: DevframeDiagnostics<typeof codes> = defineDiagnostics({
   docsBase: 'https://devfra.me/errors',
-  codes: {
-    DF0038: {
-      why: (p: { id: string, key: string, issues: string }) =>
-        `JSON-render view "${p.id}" received invalid props on element "${p.key}": ${p.issues}`,
-      fix: 'Match the element props to the base catalog\'s prop schema for that component. See the component reference for the expected shape.',
-    },
-    DF0039: {
-      why: (p: { id: string, scope: string }) =>
-        `A JSON-render view with id "${p.id}" already exists in scope "${p.scope}".`,
-      fix: 'Give each view a stable id unique within its scope, or dispose the previous view before recreating it.',
-    },
-    DF0040: {
-      why: (p: { id: string }) =>
-        `JSON-render view "${p.id}" was used after it was disposed.`,
-      fix: 'Create a fresh view with `createJsonRenderView` instead of reusing a disposed handle.',
-    },
-    DF0041: {
-      why: (p: { id: string, reason: string }) =>
-        `JSON-render view "${p.id}" spec is not JSON-serializable: ${p.reason}`,
-      fix: 'Specs and state travel as strict JSON, so remove functions, symbols, class instances, Map/Set, or circular references.',
-    },
-    DF0073: {
-      why: (p: { id: string, issues: string }) =>
-        `JSON-render view "${p.id}" does not match its configured schema: ${p.issues}`,
-      fix: 'Match the authored spec to the Standard Schema passed to `createJsonRenderView`.',
-    },
-    DF0074: {
-      why: (p: { id: string }) =>
-        `JSON-render view "${p.id}" uses an asynchronous Standard Schema.`,
-      fix: 'Use a synchronous Standard Schema so initial creation and updates remain synchronous.',
-    },
-  },
+  codes,
 })

packages/json-render/test/create-view.test.ts

@@ -1,5 +1,5 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { DevframeHost, DevframeNodeContext } from 'devframe'
+import type { StandardSchemaV1 } from 'devframe/utils/simple-schema'
 import type { DevframeJsonRenderSpec } from '../src/types'
 import { mkdtempSync } from 'node:fs'
 import { tmpdir } from 'node:os'

packages/json-render/tsdown.config.ts

@@ -12,15 +12,4 @@ export default defineConfig({
   tsconfig: '../../tsconfig.base.json',
   dts: true,
   platform: 'neutral',
-  deps: {
-    // Both are types-only in this package's public dts: `@standard-schema/spec`
-    // (a devDependency) and `nostics` (reached via `devframe/utils/nostics`,
-    // runtime import stays external on the devframe peer). Whitelisting them
-    // lets the dts bundler inline the type declarations so consumers need
-    // neither package installed for `@devframes/json-render`'s types.
-    onlyBundle: [
-      '@standard-schema/spec',
-      'nostics',
-    ],
-  },
 })