https://wal.sh/tools/transform/

Default (no params): input = Hello, World!, chain = identity encode.

Each step in the + delimited chain follows:

<codec-id>[:<arg1>[:<arg2>...]][:<direction>]

Direction tokens: d, decode, e, encode. Default: encode. Everything between the codec ID and the direction token is positional args.

The + delimiter MUST NOT be URL-encoded as %2B. The chain uses literal + in the URL. This is intentional — the pipeline reads like addition. Do NOT use URLSearchParams for chain construction; build the query string by raw concatenation.

f(f(x)) = x. One function. Direction is irrelevant. Verb: apply.

Registry shape: {:id :rot13 :label "rot13" :fn rot13 :involution? true :inverse? true}

decode(encode(x)) = x but encode ≠ decode. Two separate functions. Verb: encode or decode.

Registry shape: {:id :base64 :label "base64" :encode encode-fn :decode decode-fn :inverse? true}

A factory function receives [args] dir and returns (string → string). The same arg means different things depending on direction.

Registry shape:

{:id :caesar :label "caesar"
 :make-fn (fn [args dir]
            (let [n (parse (first args))
                  shift (if (= dir :decode) (- 26 n) n)]
              #(rot-n shift %)))
 :inverse? true :involution? false}

Note: the shift N is applied mod 26, so every integer is a valid argument and no range check is needed — caesar:0 and caesar:26 are both the identity, caesar:13 is rot13, caesar:-1 equals caesar:25. The examples below cover the cases; the formal domain is left for the reimplementation to synthesize.

Case is preserved: [A-Z] shift within uppercase, [a-z] within lowercase, and every other character (digits, punctuation, spaces, non-ASCII) passes through unchanged. So rot13 applied to [VADER] No. I am your father. yields [INQRE] Ab. V nz lbhe sngure. — brackets, period, spaces, and case all intact.

caesar:13 is the only codec where direction changes the shift amount rather than selecting a different function.

Information is destroyed. Verb: apply. Decode is nil or cosmetic. Pipeline turns red/amber at this step.

Registry shape: {:id :sort :label "sort" :encode sort-fn :decode nil :inverse? false}

Identical to Clojure's (-> input f1 f2 f3).

1. Start with text param as initial value
2. For each step left-to-right, resolve the function and apply it
3. Record the intermediate value after each step (the trace)
4. Halt on first error

The trace is the core data structure — it drives both the visual overlay and the output.

Given a step {:id :base64 :direction :encode :args []}:

1. Look up codec by :id
2. If codec has :make-fn: call (make-fn args direction) → function
3. If codec has :fn: use it (involution, direction irrelevant)
4. Otherwise: (get codec direction) → :encode or :decode function

A step is reversible when:

(and (:inverse? codec)
     (or (:involution? codec)      ; f = f⁻¹
         (:make-fn codec)          ; factory handles both directions
         (some? (get codec (opposite direction)))))  ; partner fn exists

A pipeline is reversible when every step is reversible.

To invert a pipeline:

1. Reverse the step order
2. Flip each step's direction (:encode ↔ :decode)
3. Involutions keep :encode (direction is irrelevant)
4. Preserve :args — parameterized codecs need their arguments

;; Forward:  [{:id :caesar :direction :encode :args ["3"]}]
;; Reversed: [{:id :caesar :direction :decode :args ["3"]}]
;; The "3" stays — make-fn interprets it as shift-23 when dir=:decode

Pipeline → URL chain param:

• Join steps with +
• Each step: <id> (encode) or <id>:d (decode)
• With args: <id>:<arg1>:<arg2> or <id>:<arg1>:d
• Encode direction is the default — the :e suffix is DROPPED. rot13 means encode. rot13:d means decode. There is no rot13:e in canonical output.

URL chain param → pipeline:

• Split on +, ,, or space
• Each token: split on :
• First segment: codec ID
• Last segment: direction if it matches d~/~e~/~encode~/~decode
• Middle segments: positional args
• :e and :encode MUST be accepted as explicit encode direction, even though steps->str never emits them.

str->steps(steps->str(pipeline)) = pipeline for all valid pipelines. The reverse does NOT hold: steps->str(str->steps("rot13:e")) = "rot13" (the explicit :e is normalized away). Implementations MUST accept both forms on input but produce only canonical form on output.

For every reversible chain, threading input through the chain and then through the reversed chain MUST return the original input:

(let [steps  (str->steps "caesar:3")
      result (thread "ET TU BRUTE" steps)        ; → "HW WX EUXWH"
      rev    (reverse-pipeline steps)
      back   (thread "HW WX EUXWH" rev)]         ; → "ET TU BRUTE"
  (assert (= "ET TU BRUTE" (:value (last back)))))

step-reversible? checks registry flags (:inverse? true), not runtime behavior. A codec could claim :inverse? true while its decode function is broken. Implementations MUST NOT rely on the flag alone for round-trip guarantees. The flag is a UI hint for the badge; the actual round-trip property is a semantic invariant that the spec asserts but does not prove.

Several codecs have restricted domains. The spec now requires these predicates for decode direction:

Attempting to decode invalid input MUST produce an error in the trace, not undefined behavior.

The spec assumes strings are sequences of Unicode code points. Implementations in UTF-16 languages (JS, Java) and UTF-8 languages (Rust, Go) MUST agree on output for ASCII input. Non-ASCII behavior is implementation-defined and should be documented per-codec.

caesar:N where encode = decode (involution) holds for N ≡ 0 and N ≡ 13 (mod 26). N ≡ 0 is the identity (caesar:0, caesar:26, caesar:-26 …). N ≡ 13 is rot13. The unique non-trivial fixed point among N ∈ {1,…,25} is N = 13.

corrupt is the only non-deterministic codec. Pipelines containing corrupt violate the purity axiom ("URL → deterministic output"). The spec's axiom applies to all pipelines EXCEPT those containing corrupt. Implementations SHOULD seed the RNG from the input for reproducibility in tests, or exclude corrupt from round-trip assertions.

The spec uses "surjection" loosely. Formally, sort is non-injective (many inputs map to one output) but whether it is surjective depends on the codomain definition. The spec means: information-destroying, no left-inverse exists. The UI label ONE-WAY is more precise than the mathematical term.