@playform/ets-hook-dsh-normalize-spaces
The DeepSeek Harness Plugin Family for PlayForm.
[!NOTE]
The space normalizer for model output - a DeepSeek Harness plugin that hooks the
llm/stream
waterfall (the interceptable wrapper around EVERY streaming model call, bound to the
LlmRuntime)
and normalizes the unicode space family in model output, live in the transcript: every visible
non-terminator space that is not the ASCII space becomes the plain ASCII space - U+00A0 to ' ',
quads and quirs alike.
A CLASS flavor of the normalize family: the core's Spaces class plus a configurable
replacement string (default " ", the plain ASCII space).
The @-sentence identity: Hook @ DSH
@ Normalize @ Spaces.
The family's raw-write tool (registered by
ets-hook-dsh-normalize-dash) bypasses this flavor's transforms too -
the exemption is family-wide: the core's Stream/Chunk + Stream/Block pass every raw-write
call through by identity, so the tool's explicit normalize parameter (default false = verbatim)
is the only normalization it applies.
Where It Fits
Family position (the @-sentence Hook @ DSH @ Normalize @ Spaces): a hook child of the
ets-plugin-dsh-factory service and the ets-hook-dsh-core
machinery; the fourth of the six stream normalizer siblings.
One of six siblings in the stream-normalization family, all built on the shared machinery -
ets-plugin-dsh-factory for State/Append (and the named Schema helper,
shared: false, for the config), ets-hook-dsh-core for the Spaces class and the
generic Replace/Chunk/Block dispatch:
A non-manifest factory consumer: it injects ["pluginFactory"] and uses State (cell
unwrap + shared Ledger/Enabled mappings + its own fields), Append and
Journal (the shared P5 record on every N > 0 pass); the config is composed
by the factory's standalone Schema helper with shared: false - the minimal block, no
fs/observed
dead fields.
It touches no files, so
fs/write-intent and
fs/observed never see it; it wraps the
downstream result and always calls next(), so it composes with other
llm/stream listeners
regardless of registration order.
The DSH plugin family is the DeepSeek Harness plugin layer of the PlayForm ecosystem:
TypeScript-first Source/ → Target/, the deterministic @playform build, prepublishOnly-only -
the same conventions as every other @playform package.
Install
Terminal (registry)
pnpm add @playform/ets-hook-dsh-normalize-spaces
- Remote / dependency install (auto-activation):
pnpm add @playform/ets-hook-dsh-normalize-spaces
in a profile dir (+ the package name in dsh.profile.bundles, or dsh plugin add) - installed
automatically and activated at the next host start.
- Local git clone: clone →
pnpm install inside the bundle (its pnpm-workspace.yaml pins
packages: [.] so the install lands in the bundle, not the workspace root) → build →
dsh plugin --profile <name> add <this directory>.
- Tarball / npm:
dsh plugin --profile <name> add <tarball-or-spec> - the package ships built
Target/ (minified, .d.ts twins), so no build runs at install time.
Verify with the ets-hook-dsh-normalize-spaces: activated (...) ledger line.
Usage
The bundle is configured through its cordis.patch.yml row (or the profile's dsh.bundle
manifest) - the full config table is in The Config:
- insert:
- id: ets-hook-dsh-normalize-spaces
name: "@playform/ets-hook-dsh-normalize-spaces"
config:
log: true
logFile: ~/.dsh/ets-hook-dsh-normalize-spaces.log
replacement: " "
The shared Effect-TS plumbing - the runtime wiring, the stream machinery and the hook contract types - comes from the base ets-base-dsh package.
The Problem
Model output picks up exotic spaces - the no-break space from copy-pasted prose, the thin space from
typographic text, the ideographic space from CJK input.
Markdown renderers and shell quoting do not
treat them as spaces; a command with a U+00A0 in it fails for no visible reason.
This flavor makes
the plain ASCII space the one that reaches the transcript.
How It Works
The stream pipeline
llm/stream waterfall (options, next) the interceptable wrapper around
│ EVERY streaming model call
▼ next() called FIRST, always - options never touched
Normalize(upstream, state) the async generator
│ for await (chunk of upstream)
▼
CoreChunk(chunk, transform, reasoning, toolArgs, raw) the core's per-chunk dispatch
│
├─ text-delta ────────► Replace(text, Spaces, " ") rewrite the text field
├─ reasoning-delta ───► same, when normalizeReasoning (default ON)
├─ block-end ─────────► the assembled block's text fields -
│ TextBlock.text / ReasoningBlock.text (plus a
│ runtime `thinking` string field) - the deltas
│ AND the block must agree, or consumers see
│ inconsistencies
├─ tool-call-delta ───► Replace(argumentsDelta, Spaces, " ") when
│ normalizeToolArguments (IMPLEMENTED, default
│ OFF - execution-critical raw JSON, the user's
│ accepted risk; the example patch turns it
│ on) - the assembled ToolCallBlock.arguments
│ follows the same flag via block-end
│ The gate is THREE-WAY with the flag on: a
│ delta/block whose `name` is "edit", "raw-write"
│ or "normalize-file" passes through BY IDENTITY
│ (the edit tool's `old_string` must match the real
│ file bytes; the raw-write tool owns its content
│ normalization; the normalize-file tool's arguments
│ carry a file path - a normalized dash inside a
│ filename would corrupt the target),
│ and a call whose arguments open with the
│ `{"__normalize":false` marker (FIRST key,
│ tracked per call id) passes through
│ UNNORMALIZED with the marker entry stripped,
│ so the executed call carries no unknown key
└─ block-start / usage / finish
──► PASSTHROUGH BY IDENTITY, ALWAYS
(usage/finish ordering is the
adapter contract)
│ count === 0 → original chunk BY IDENTITY; rewritten → shallow copy
▼
yield ──► downstream consumers = the live UI + the durable transcript
│ (order preserved, no buffering; upstream throws propagate)
▼ normal loop completion, Count > 0
Factory.Append ──► `ets-hook-dsh-normalize-spaces: normalized N space char(s) in one stream`
The transform
Exactly the core's Spaces class (@playform/ets-hook-dsh-core's Normalize/Spaces), applied per text
segment through the core's generic class-to-string Replace:
[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000] → replacement
U+00A0 (no-break space), U+1680 (ogham space mark), U+2000 through U+200A (en quad, em quad, en
space, three-per-em, four-per-em, six-per-em, figure space, punctuation space, thin space, hair
space), U+202F (narrow no-break space), U+205F (medium mathematical space) and U+3000 (ideographic
space) - exactly Unicode's Zs category minus the ASCII space - become the config replacement
(default " ", the plain ASCII space U+0020).
- No context rules - whole-chunk replacement, no lookahead; chunk-boundary-safe.
- The replacement is applied with a function replacer, so a custom
replacement containing $
patterns is inserted literally.
- Replaced characters are counted per stream for the ledger line.
The Pitfalls
- Zs minus ASCII - the class is the unicode space family (U+00A0, U+1680, U+2000-U+200A, U+202F,
U+205F, U+3000); tabs and newlines are not spaces and never match.
- A dependency alone is NOT activation - the package must be in
dsh.profile.bundles (or the
patch row inserted), or no listener registers and no ledger exists.
- The stream gate rewrites model output only - it never touches disk; files already on disk are
the
normalize-file tool's job.
- The count is per replaced code point - N counts matched characters; N = 0 and an upstream
throw both write no count line and no journal record.
The Config
| Field | Type | Default | Volatile | Meaning |
|---|
log | boolean | true | yes | write the durable ledger file |
logFile | string | ~/.dsh/ets-hook-dsh-normalize-spaces.log | yes | the spaces ledger (separate from the family's logs) |
replacement | string | " " | yes | the transform's only knob - hot-editable, the next stream picks it up with no remount |
normalizeReasoning | boolean | true | no | normalize reasoning deltas and the assembled reasoning block too |
normalizeToolArguments | boolean | false | no | IMPLEMENTED (default OFF): rewrite the tool-call argumentsDelta and the assembled ToolCallBlock.arguments when on (with three exemptions: edit, raw-write and normalize-file calls pass through by identity (the edit tool's old_string must match the real file bytes; the raw-write tool owns its content normalization through its explicit normalize parameter; the normalize-file tool's arguments carry a file path - a normalized dash inside a filename would corrupt the target); and a call whose arguments open with the {"__normalize":false first-key marker passes through unnormalized, the marker entry stripped) - execution-critical raw JSON, the user's accepted risk; the example patch turns it on |
Volatile cells commit without remounting the plugin; the factory's State builder unwraps them
defensively.
In Action
One stream, one transformation.
The model emits copy-pasted typographic spacing; the live UI and the
transcript receive plain ASCII spaces.
In the incoming line below the three gaps are the no-break
space U+00A0, the em quad U+2003 and the ideographic space U+3000, in that order:
text-delta in (what the model wrote; each marked gap is a non-ASCII space):
deploy the agent to the ring buffer
text-delta out (what reaches the transcript):
"deploy the agent to the ring buffer"
Each non-ASCII space in the Zs-minus-ASCII class - U+00A0 between deploy and the, U+2003 between
agent and to, U+3000 between ring and buffer in the sample above - becomes exactly one ASCII
space (U+0020); ASCII spaces that were already there are untouched.
This is what makes a pasted
command executable again: echo a b with the no-break space U+00A0 between the arguments runs after
the pass, where before the pass the shell saw one mangled word.
When a stream finishes normally with
replacements made, the ledger gets the count line (note the replacement= field renders the
default as a bare space):
ets-hook-dsh-normalize-spaces: normalized 3 space char(s) in one stream
The replacement is hot-editable (say to _ for debugging), and the same pass runs over reasoning
deltas when normalizeReasoning is on and over tool-call arguments when the example patch enables
normalizeToolArguments - with the edit, raw-write and normalize-file names exempt and raw-marker calls passing through
unnormalized.
The Ledger
Two lines, both written through the factory's Append (the ets-hook-dsh-normalize-spaces: prefix is
the logger's <State.Module>:; the durable file line is [<ISO>] <message>):
ets-hook-dsh-normalize-spaces: activated (replacement= , reasoning=on, toolArgs=off, logFile=~/.dsh/ets-hook-dsh-normalize-spaces.log)
ets-hook-dsh-normalize-spaces: normalized N space char(s) in one stream
(In the activation line, replacement= is followed by the ASCII space itself - the default renders
as a trailing blank.)
The activation line is written by apply(); the count line only follows a normal stream completion
and only when N > 0 (a thrown-away stream writes no ledger line).
Every N > 0 pass also journals one normalized record into the shared package_governance v2
domain - event normalized, path = the empty stream-level path, detail byte-identical to the
count line - best-effort: with no storage facility the record buffers or drops, and the human
ledger stays the complete record.
License 📜
CC0-1.0.
