dsh-client-ui-enter-newline 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-client-ui-enter-newline contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# dsh-client-ui-enter-newline
+
+A DSH Web client plugin. It adds one checkbox — **Enter 键仅换行** — to the left of the
+model / reasoning-effort selector in the composer toolbar:
+
+| Checkbox | Plain `Enter` | `Shift`+`Enter` | `Ctrl`/`Cmd`+`Enter` |
+|---|---|---|---|
+| unchecked (default) | sends, exactly as shipped | line break | shipped accelerated send |
+| checked | line break, **submit is suppressed** | line break | shipped accelerated send |
+
+The preference is stored in the browser under `localStorage['dsh.enterNewlineOnly']`
+(`"1"` = checked). A missing or unreadable key means unchecked, so the plugin's
+default state is the untouched DSH behavior.
+
+## Layout
+
+| File | Role |
+|---|---|
+| `lib/index.js` | Host half: an empty Cordis entry, so the loader has something to mount. |
+| `lib/client.js` | Browser half: the checkbox component, the preference store, and the Enter guard. |
+
+## How it hooks in
+
+* **The checkbox** is registered into the shipped `conversation.input.left` slot —
+  the composer toolbar row's leading group. That group renders as a sibling
+  immediately before the trailing group that holds `conversation.input.right` and the
+  model selector, so the control lands directly on the selector's left with the
+  toolbar's own flex spacing. The plugin adds one inline cell; no shipped markup is
+  replaced, reordered, or restyled. The slot is session-scoped and is never hidden by
+  the toolbar's activity expansion, so the control lives exactly as long as the
+  resident composer does.
+* **The Enter guard** is a `keydown` listener in the capture phase, registered on
+  `window` and on `document`. The composer's Enter command lives inside Lexical, which
+  listens on the editor root in the bubble phase, so a capturing listener runs strictly
+  earlier. When the checkbox is on and the event is a plain Enter inside the composer's
+  draft host, the listener stops propagation — Lexical never sees the key, and because
+  the event is *not* `preventDefault()`ed the browser still inserts the line break,
+  which is exactly what `Shift`+`Enter` does. Every other key, and every Enter while
+  the checkbox is off, is untouched.
+* **The draft host is detected from the live node**, not a fixed attribute value: any
+  element whose `isContentEditable` is true (which also covers
+  `contenteditable="plaintext-only"`) or a `textarea`, as long as it sits inside a
+  `[data-composer-card]`. A kernel release that changes how the draft is hosted
+  therefore cannot silently disable the guard, and no editor outside the composer is
+  ever touched.
+* **The preference the guard acts on is read from the rendered control itself**
+  (`checked` on the plugin's own checkbox), not from an in-memory copy, with the
+  page-global record as the fallback for moments when the control is unmounted. The
+  control's `checked` property is the value the user is looking at, so nothing that can
+  desynchronize memory — a hot reload leaving an older bundle execution's listener
+  installed, or a storage write that never landed — can make the guard disagree with
+  the checkbox on screen. Two historical bugs came from getting this wrong: a
+  module-local flag that went stale across reloads, and a seat check that also excluded
+  anything inside a composer card *containing* the seat (which is true of the composer's
+  own editor, so the guard skipped exactly the events it exists for). The regression
+  tests in `test/guard.test.mjs` cover both.
+
+`Shift`/`Ctrl`/`Meta`/`Alt`/`AltGr` chords and IME composition are never intercepted.
+
+## Install
+
+The package declares `dsh.bundle.patch`, so it installs as an ordinary DSH bundle and
+registers its own loader entry — no hand-edited YAML, no build step on the user's
+machine:
+
+```sh
+dsh plugin --profile <profile> add dsh-client-ui-enter-newline     # from npm
+dsh plugin --profile <profile> add ./dsh-client-ui-enter-newline-1.0.0.tgz   # from a tarball
+dsh plugin --profile <profile> add github:<you>/<repo>             # from a git host
+```
+
+`add` appends the bundle to `dsh.profile.bundles`; `dsh plugin --profile <profile>
+remove dsh-client-ui-enter-newline` takes it back out. Check the composed tree before
+booting with `dsh --profile <profile> --dump-config`.
+
+Installing by hand is equally fine: put the package where the profile's module
+resolution can see it and add the same row the bundle layer adds —
+
+```yaml
+# <DSH_HOME>/profiles/<profile>/cordis.patch.yml
+- insert:
+    - id: enter-newline
+      name: 'dsh-client-ui-enter-newline'
+```
+
+A profile that watches its patch file picks the entry up live: the host side becomes an
+active loader entry and the browser half mounts without restarting DSH. A profile that
+does not hot-reload its patch layer needs a restart.
+
+## Distribute
+
+Publish the **built** package — the bundle is plain JavaScript, so there is nothing to
+compile, and `lib/` ships as-is. Three routes, in order of how little the user has to do:
+
+| Route | User command | Build on install |
+|---|---|---|
+| npm | `dsh plugin add dsh-client-ui-enter-newline` | none |
+| tarball (`pnpm pack`) | `dsh plugin add ./dsh-client-ui-enter-newline-1.0.0.tgz` | none |
+| git host | `dsh plugin add github:you/repo` | `prepare` must build `lib/`, and the user must allow it |
+
+Prefer npm or a tarball: pnpm ≥10 refuses to run a git dependency's `prepare` script
+until the user explicitly allows it in the profile's `pnpm-workspace.yaml`
+(`allowBuilds:`), and that permission is "let this package run code on my machine at
+install time". Distributing built artifacts keeps that decision off the user's plate.
+
+Before publishing, the five fields that decide whether an install *works* rather than
+merely *succeeds*:
+
+1. `main` / `exports` point at the built entry (`lib/index.js`), never at sources;
+2. `"type": "module"`;
+3. `files` includes the entry **and** `cordis.patch.yml` — the patch is the bundle layer,
+   so omitting it yields a package that installs but activates nothing;
+4. `dsh.bundle.patch` points at that patch file — without it the package is only a plain
+   dependency and `dsh plugin` warns that no layer was activated;
+5. `version` bumped per semver — a published version can never be overwritten.
+
+Then:
+
+```bash
+pnpm pack --dry-run          # confirm lib/ + cordis.patch.yml are inside the tarball
+pnpm publish                 # scoped packages: publishConfig.access = public
+dsh plugin --profile fresh add ./dsh-client-ui-enter-newline-1.0.0.tgz
+dsh --profile fresh --dump-config     # expect a "# == dsh-client-ui-enter-newline" layer
+```
+
+Verify in a **fresh** profile: an install tested in your own profile can pass on
+dependencies that happen to be there already.
+
+## Verify
+
+```bash
+node test/guard.test.mjs lib/client.js
+```
+
+The check loads the real bundle against a minimal DOM stub and asserts the shipped
+behavior, the suppressed behavior, every un-intercepted chord, IME composition,
+out-of-composer targets, `plaintext-only` and detached draft hosts, and the checked
+styling on mount. It deliberately cannot prove anything about the live Lexical editor
+or the shipped markup — open the composer and press `Enter` for that.
+
+Two live probes confirm the wiring without touching the page:
+
+* `cordis_inspect_query` → host `Config` → `listConfigs` with
+  `{"name": "dsh-client-ui-enter-newline"}` returns the loader entry.
+* `cordis_inspect_query` → client `Slots` → `listSubTree` with
+  `{"root": "conversation.input.left"}` lists `enter-newline-toggle` as an active
+  occupant.
+
+## Uninstall
+
+Delete the loader entry above, then the installed package directory. The stored
+preference key is inert on its own and can be removed with
+`localStorage.removeItem('dsh.enterNewlineOnly')`.
+
+## Limitations
+
+* The guard targets the composer's plain `Enter`. The primary Send button is a
+  separate control and still sends while the checkbox is on — by design: the
+  preference is about the keyboard, and a button is an explicit click.
+* While the checkbox is on, React's synthetic `keydown` for that specific Enter is
+  suppressed along with the composer command. This is intentional (no submit path may
+  remain) and affects no other event.
+* The guard locates the composer card and the rendered control through the shipped
+  `[data-composer-card]` marker plus this plugin's own `data-enter-newline-seat`; the
+  draft host itself is recognised via `isContentEditable` (or `textarea`). A DSH release
+  that renames `data-composer-card` would make the plugin stop finding the control, and
+  the guard then falls back to its stored preference — so the checkbox keeps working,
+  while the "read exactly what the user sees" guarantee no longer holds. Re-check that
+  marker after a kernel upgrade.

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# Insert the client-only plugin entry. The package owns no Config, so the entry
+# carries none: the host half exists only so the loader can mount it, and the whole
+# feature is the browser half declared by `dsh.client` in package.json.
+- insert:
+    - id: enter-newline
+      name: 'dsh-client-ui-enter-newline'

package/lib/client.js

@@ -0,0 +1,406 @@
+/**
+ * Browser half of `dsh-client-ui-enter-newline`.
+ *
+ * Feature: a checkbox in the top-right corner of the composer card labelled
+ * "Enter 键仅换行" (Enter inserts a newline only). Checked  -> plain Enter inserts a
+ * line break and never submits. Unchecked -> the shipped composer behavior, where
+ * plain Enter sends and Shift+Enter inserts a line break. The default is unchecked.
+ *
+ * How the Enter guard works
+ * -------------------------
+ * The shipped composer binds its Enter command inside Lexical, which listens on the
+ * editor root element in the DOM bubble phase (`registerComposerKeymap` in
+ * `@deepseek-ai/dsh-client-ui-conversation`). Its handler calls `preventDefault()`
+ * and submits. A document-level *capture* listener therefore runs strictly earlier,
+ * and stopping propagation there keeps the command from ever reaching Lexical.
+ * The event is deliberately not `preventDefault()`ed, so the browser's own
+ * contenteditable behavior (insert a line break) still applies — exactly the
+ * Shift+Enter path.
+ *
+ * Because the bubble phase is cut, React's delegated synthetic `keydown` also never
+ * sees the event. That is deliberate: when the checkbox is on, Enter must not reach
+ * any submit path. Every other key, and every Enter while the checkbox is off, is
+ * left completely untouched.
+ *
+ * Markup contract this plugin relies on (all shipped `data-*`, not CSS hashes):
+ *   `[data-composer-card]`  the resident composer card
+ *   `[data-composer-seat]`  the composer seat wrapper (fallback anchor)
+ * The checkbox fills the composer's own `conversation.input.left` seat — the toolbar
+ * row's leading group, which renders immediately before the trailing group holding
+ * the model / reasoning-effort selector. The seat is session-scoped and never hidden
+ * by the toolbar's activity expansion, so the control lives exactly as long as the
+ * resident composer does.
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-client-ui-enter-newline',
+  factory: (require) => {
+    const module = { exports: {} }
+    const exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+    const { createElement: h, useCallback, useEffect, useRef, useState } = React
+
+    // ------------------------------------------------------------------
+    // Constants
+    // ------------------------------------------------------------------
+
+    const PLUGIN_ID = 'dsh-client-ui-enter-newline'
+    const CSS_TAG = PLUGIN_ID + '/client.css'
+    const STORAGE_KEY = 'dsh.enterNewlineOnly'
+    const SEAT_ATTR = 'data-enter-newline-seat'
+    const SEAT_SELECTOR = '[' + SEAT_ATTR + ']'
+    /** Composer toolbar seat: leading group, rendered before the model selector. */
+    const SLOT = 'conversation.input.left'
+    const CARD_SELECTOR = '[data-composer-card]'
+
+    const LABEL = 'Enter 键仅换行'
+
+    // ------------------------------------------------------------------
+    // Styles (namespace: `denl-`, theme tokens only)
+    //
+    // The seat is an inline cell of the composer toolbar row, whose own flex rules
+    // (`align-items:center`, `gap:12px`) already space it from the model selector to
+    // its right. Nothing here positions the control absolutely.
+    // ------------------------------------------------------------------
+
+    const CSS = [
+      '.denl-root{display:inline-flex;align-items:center;min-width:0;flex:none}',
+      '.denl-row{display:flex;align-items:center;gap:6px;cursor:pointer;user-select:none;-webkit-user-select:none;margin:0}',
+      '.denl-box{position:relative;flex:none;display:grid;place-items:center;width:14px;height:14px;border:1px solid var(--dsw-alias-border-l3);border-radius:4px;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary);transition:background .12s,border-color .12s}',
+      '.denl-row:hover .denl-box{border-color:var(--dsw-alias-label-tertiary)}',
+      '.denl-input{position:absolute;width:100%;height:100%;margin:0;opacity:0;cursor:pointer}',
+      '.denl-root[data-on="1"] .denl-box{background:var(--dsw-alias-state-business-primary);border-color:var(--dsw-alias-state-business-primary);color:var(--dsw-alias-label-secondary)}',
+      '.denl-input:focus-visible+.denl-box{outline:var(--dsw-focus-ring-width,2px) solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:1px}',
+      '.denl-check{opacity:0;transition:opacity .12s}',
+      '.denl-root[data-on="1"] .denl-check{opacity:1}',
+      '.denl-label{font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary);white-space:nowrap;cursor:pointer}',
+      '.denl-root[data-on="1"] .denl-label{color:var(--dsw-alias-label-secondary)}'
+    ].join('')
+
+    let cssDisposer = null
+
+    /**
+     * Removes a diagnostic readout left behind by an earlier build of this plugin.
+     *
+     * That readout was a fixed-position element appended straight to `<body>` during
+     * development, so a hot reload orphaned it: no execution owned it any more, and it
+     * stayed on screen. The plugin now sweeps it away on activation, which both cleans
+     * existing pages and makes the removal self-healing for anyone else who ran that
+     * build. The id is private to this plugin, so nothing else can match it.
+     */
+    function removeStaleReadout() {
+      if (typeof document === 'undefined') return
+      const stale = document.getElementById('denl-debug')
+      if (stale !== null && stale !== undefined && typeof stale.remove === 'function') stale.remove()
+    }
+
+    function ensureCss() {
+      if (cssDisposer !== null) return
+      if (typeof document === 'undefined') return
+      if (document.querySelector('style[data-plugin-css=' + JSON.stringify(CSS_TAG) + ']') !== null) return
+      const tag = document.createElement('style')
+      tag.dataset.plugin = PLUGIN_ID
+      tag.dataset.pluginCss = CSS_TAG
+      tag.textContent = CSS
+      document.head.appendChild(tag)
+      cssDisposer = () => {
+        tag.remove()
+        cssDisposer = null
+      }
+    }
+
+    // ------------------------------------------------------------------
+    // Preference store (page-global, localStorage-backed)
+    //
+    // The state deliberately lives on a single object parked on `window` rather than
+    // in module-local variables. A client plugin is re-executed on every hot reload,
+    // and each execution gets fresh module locals: a listener installed by one
+    // execution would then read a stale flag while the control rendered by another
+    // execution had already been switched on. One shared record per page makes every
+    // execution — and therefore every guard listener and every rendered control —
+    // observe exactly the same value.
+    // ------------------------------------------------------------------
+
+    const STORE_KEY = '__dshEnterNewlineStore'
+
+    function readStored() {
+      try {
+        return window.localStorage.getItem(STORAGE_KEY) === '1'
+      } catch {
+        // Storage blocked (private mode): fall back to the shared in-page record.
+        const fallback = window[STORE_KEY]
+        return fallback !== undefined && fallback.value === true
+      }
+    }
+
+    function createStore() {
+      return {
+        /** Default is unchecked: the shipped composer behavior. */
+        value: readStored(),
+        listeners: new Set()
+      }
+    }
+
+    /** Shared across bundle executions; created once per page. */
+    const store = (() => {
+      const existing = window[STORE_KEY]
+      if (existing !== undefined && existing !== null && existing.listeners instanceof Set) return existing
+      const created = createStore()
+      window[STORE_KEY] = created
+      return created
+    })()
+
+    function getNewlineOnly() {
+      return store.value === true
+    }
+
+    /**
+     * The authoritative preference for the Enter guard.
+     *
+     * The rendered control is read first: a checkbox's `checked` property is the value
+     * the user is looking at, and it survives anything that can desynchronize an
+     * in-memory copy — a hot reload that leaves an older bundle execution's listener
+     * installed, or a storage write that never landed. The shared record is only the
+     * fallback for the moments when the control is not mounted.
+     */
+    function preferenceIsNewlineOnly() {
+      if (typeof document !== 'undefined') {
+        const control = document.querySelector(CARD_SELECTOR + ' ' + SEAT_SELECTOR + ' input[type="checkbox"]')
+        if (control !== null && control !== undefined) return control.checked === true
+      }
+      return getNewlineOnly()
+    }
+
+    function setNewlineOnly(next) {
+      const value = next === true
+      if (value === store.value) return
+      store.value = value
+      try {
+        window.localStorage.setItem(STORAGE_KEY, value ? '1' : '0')
+      } catch {
+        // Non-persistent storage: the shared in-page record keeps the value.
+      }
+      for (const listener of Array.from(store.listeners)) {
+        try {
+          listener()
+        } catch (error) {
+          console.error('[enter-newline] listener failed', error)
+        }
+      }
+    }
+
+    function subscribeNewlineOnly(listener) {
+      store.listeners.add(listener)
+      return () => {
+        store.listeners.delete(listener)
+      }
+    }
+
+    // ------------------------------------------------------------------
+    // Composer Enter guard
+    // ------------------------------------------------------------------
+
+    /** Prefix keys that must keep their shipped meaning even in newline-only mode. */
+    function hasModifier(event) {
+      return event.shiftKey || event.ctrlKey || event.metaKey || event.altKey || event.getModifierState('AltGraph')
+    }
+
+    /**
+     * Whether `node` is this plugin's own control (or inside it).
+     *
+     * Only the ancestor chain is consulted. An earlier revision also excluded anything
+     * inside a composer card that merely *contained* the seat — which is true of the
+     * composer's own draft editor, so the guard silently skipped exactly the events it
+     * exists to handle. The seat is always an ancestor of the control's own nodes.
+     */
+    function inOwnSeat(node) {
+      let current = node
+      while (current !== null && current !== undefined) {
+        if (current.nodeType === 1 && typeof current.hasAttribute === 'function' && current.hasAttribute(SEAT_ATTR)) {
+          return true
+        }
+        current = current.parentNode
+      }
+      return false
+    }
+
+    /**
+     * The composer's own draft host: an editable element inside a composer card.
+     *
+     * Editable-ness is read from the live node (`isContentEditable`, which also covers
+     * `contenteditable="plaintext-only"`) instead of a fixed attribute value, and
+     * `textarea` is accepted too, so a kernel change in how the draft is hosted cannot
+     * silently disable the guard. The composer-card requirement keeps the guard from
+     * ever touching an editor outside the composer.
+     */
+    function isComposerEditor(node) {
+      if (node === null || node === undefined || node.nodeType !== 1) return false
+      if (typeof node.closest !== 'function') return false
+      if (node.isContentEditable !== true && node.tagName !== 'TEXTAREA') return false
+      return node.closest(CARD_SELECTOR) !== null
+    }
+
+    function onDocumentKeydown(event) {
+      if (!preferenceIsNewlineOnly()) return
+      if (event.defaultPrevented) return
+      if (event.key !== 'Enter' && event.keyCode !== 13) return
+      if (event.isComposing || event.keyCode === 229) return
+      if (hasModifier(event)) return
+      const target = event.target
+      if (!isComposerEditor(target)) return
+      if (inOwnSeat(target)) return
+      // Swallow the composer's Enter command; the browser inserts the line break.
+      event.stopPropagation()
+    }
+
+    /**
+     * Keep keyboard focus in the draft and hand focus to the checkbox, so toggling
+     * the preference never interrupts typing while the control stays tab-reachable.
+     */
+    function focusArtifact(event) {
+      const input = event.currentTarget.querySelector('input')
+      if (input !== null) input.focus({ preventScroll: true })
+    }
+
+    /**
+     * Own the Enter guard for exactly as long as the plugin is active.
+     *
+     * The listener is registered on `window` *and* `document`, both in the capture
+     * phase: whichever runs first stops the event before the editor's own bubble-phase
+     * host and any delegated listener above it can see it. Stopping twice is harmless.
+     */
+    function installEnterGuard() {
+      if (typeof document === 'undefined') return () => {}
+      const owner = typeof window === 'undefined' ? null : window
+      document.addEventListener('keydown', onDocumentKeydown, true)
+      if (owner !== null) owner.addEventListener('keydown', onDocumentKeydown, true)
+      return () => {
+        document.removeEventListener('keydown', onDocumentKeydown, true)
+        if (owner !== null) owner.removeEventListener('keydown', onDocumentKeydown, true)
+      }
+    }
+
+    // ------------------------------------------------------------------
+    // React control
+    // ------------------------------------------------------------------
+
+    function syncSeatFlag(node, on) {
+      if (node === null) return
+      if (on) node.setAttribute('data-on', '1')
+      else node.removeAttribute('data-on')
+    }
+
+    function EnterNewlineToggle() {
+      const [on, setOn] = useState(getNewlineOnly)
+
+      useEffect(() => {
+        const listener = () => setOn(getNewlineOnly())
+        const unsubscribe = subscribeNewlineOnly(listener)
+        // The shared record may have moved on between render and effect (another
+        // execution's control, or a reload), so re-read it once on mount.
+        listener()
+        return unsubscribe
+      }, [])
+
+      const onChange = useCallback((event) => {
+        // Read the control's own state, not the event payload: the payload is the
+        // same either way, and the DOM property is the value the user sees.
+        setNewlineOnly(event.currentTarget.checked === true)
+        // `mousedown` was suppressed to protect the draft's focus, so move the
+        // focus ring to the control explicitly and keep it operable from the keyboard.
+        focusArtifact(event)
+      }, [])
+
+      const onRowMouseDown = useCallback((event) => {
+        // Keep the caret in the draft instead of moving focus to the checkbox, so
+        // toggling the preference never interrupts typing.
+        event.preventDefault()
+      }, [])
+
+      const box = h(
+        'span',
+        { className: 'denl-box' },
+        h(
+          'svg',
+          {
+            className: 'denl-check',
+            width: 10,
+            height: 10,
+            viewBox: '0 0 12 12',
+            fill: 'none',
+            'aria-hidden': 'true'
+          },
+          h('path', {
+            d: 'M2 6.4 4.6 9 10 3.2',
+            stroke: 'currentColor',
+            strokeWidth: 1.8,
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round'
+          })
+        ),
+        h('input', {
+          className: 'denl-input',
+          type: 'checkbox',
+          checked: on,
+          onChange,
+          'aria-label': LABEL,
+          tabIndex: 0
+        })
+      )
+
+      return h(
+        'div',
+        {
+          className: 'denl-root',
+          // The seat's checked styling is a container attribute so the rest of the
+          // markup stays declarative; a ref callback keeps it in step with the render
+          // that owns this state, with no extra effect or keyed pass.
+          ref: (node) => syncSeatFlag(node, on),
+          [SEAT_ATTR]: 'true',
+          onClick: (event) => event.stopPropagation(),
+          onPointerDown: (event) => event.stopPropagation()
+        },
+        h(
+          'label',
+          { className: 'denl-row', title: LABEL, onMouseDown: onRowMouseDown },
+          box,
+          h('span', { className: 'denl-label' }, LABEL)
+        )
+      )
+    }
+
+    // ------------------------------------------------------------------
+    // Plugin entry
+    // ------------------------------------------------------------------
+
+    function apply(ctx) {
+      // Runs before the stylesheet short-circuit below, so the sweep happens on every
+      // activation — including a hot reload that inherits an already-installed sheet.
+      removeStaleReadout()
+      ensureCss()
+
+      ctx.slots.inject(SLOT, () =>
+        ctx.slots.register(
+          {
+            name: SLOT,
+            id: 'enter-newline-toggle',
+            order: 100,
+            label: LABEL
+          },
+          EnterNewlineToggle
+        )
+      )
+
+      ctx.effect(() => installEnterGuard(), 'enter-newline: composer Enter guard')
+      ctx.effect(() => () => {
+        if (cssDisposer !== null) cssDisposer()
+      }, 'enter-newline: stylesheet')
+    }
+
+    exports.apply = apply
+    exports.inject = ['slots']
+    return module.exports
+  }
+})

package/lib/index.js

@@ -0,0 +1,17 @@
+/**
+ * Host half of `dsh-client-ui-enter-newline`.
+ *
+ * The whole feature lives in the browser: a checkbox rendered into the composer's
+ * floating overlay plus a document-level Enter guard. The host half therefore only
+ * has to exist as a loadable Cordis entry — it declares no Config, provides no
+ * Service, contributes no prompt text, and registers nothing model-facing.
+ */
+
+/**
+ * Activate the host half.
+ *
+ * Intentionally empty: this plugin owns no Host state. The loader entry in
+ * `cordis.patch.yml` supplies the id and module name, matching the pattern used by
+ * the other client-only plugins in this profile.
+ */
+export function apply() {}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "dsh-client-ui-enter-newline",
+  "version": "1.0.0",
+  "description": "DSH Web client plugin: an \"Enter inserts a newline only\" checkbox beside the composer's model selector, which suppresses Enter-to-send while checked.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "react",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ],
+      "platform": "web"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "composer",
+    "enter",
+    "newline"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}