From ef3bd00ee9cd636297df962ad909f14cb24cb8f6 Mon Sep 17 00:00:00 2001
From: Ronald Tse <ronald.tse@ribose.com>
Date: Tue, 28 Jul 2026 07:05:59 +0800
Subject: [PATCH] =?UTF-8?q?feat:=200.2.0=20=E2=80=94=20CLI,=20per-category?=
 =?UTF-8?q?=20operator=20specs,=20round-trip=20property?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a Thor-based CLI (postscript parse/serialize/tokenize/version)
and a top-level convenience API (Postscript.parse / serialize /
tokenize) for ad-hoc PS source inspection without writing Ruby.

Add one spec file per operator category (13 files) covering
from_operands arity, stack ordering, and value semantics.

Add a round-trip property spec covering 6 representative PS
programs. The property caught two real bugs in the serializer
that are fixed in this commit:

1. Serializer always appended showpage even when the program body
   already contained one — accumulated duplicates on each round-
   trip. Now checks body_has_showpage? first.

2. Serializer had per-operator emit_keyword methods that inlined
   operands, but the parser ALSO puts operands in body as
   standalone literal statements. Each round-trip doubled the
   literal count. Removed all per-operator emitters; the generic
   emit_operator now emits just the keyword, and operands are
   emitted as their own literal statements.

3. Serializer did not emit HiResBoundingBox even when the header
   had it. Now emits both BoundingBox and HiResBoundingBox.

Also:
- Add missing consumes/produces declarations to all Boolean ops
  and Transformations::Matrix.
- Frozen-string literals on every .rb file.
- Initial CHANGELOG, LICENSE, .gitignore, .rubocop.yml.
- GitHub Actions workflows: rake.yml (CI), release.yml (trusted
  publishing via metanorma/ci).

149 specs, 0 failures. postsvg (downstream) still passes 124/124.
---
 CHANGELOG.md                                  |  71 ++++++
 LICENSE                                       |  24 ++
 exe/postscript                                |   7 +
 lib/postscript.rb                             |  30 +++
 lib/postscript/cli.rb                         |  83 +++++++
 lib/postscript/model/operators/boolean.rb     |  22 +-
 .../model/operators/transformations.rb        |   2 +-
 lib/postscript/serializer.rb                  | 222 ++----------------
 postscript.gemspec                            |   2 +
 .../model/operators/arithmetic_spec.rb        |  91 +++++++
 .../model/operators/boolean_spec.rb           |  62 +++++
 spec/postscript/model/operators/color_spec.rb |  50 ++++
 .../model/operators/container_spec.rb         |  57 +++++
 .../model/operators/control_flow_spec.rb      |  66 ++++++
 .../postscript/model/operators/device_spec.rb |  17 ++
 .../model/operators/dictionary_spec.rb        |  59 +++++
 spec/postscript/model/operators/font_spec.rb  |  44 ++++
 .../model/operators/graphics_state_spec.rb    |  51 ++++
 .../model/operators/painting_spec.rb          |  22 ++
 spec/postscript/model/operators/path_spec.rb  |  77 ++++++
 spec/postscript/model/operators/stack_spec.rb |  72 ++++++
 .../model/operators/transformations_spec.rb   |  50 ++++
 spec/postscript/round_trip_spec.rb            | 119 ++++++++++
 spec/postscript/serializer_spec.rb            |   6 +-
 24 files changed, 1086 insertions(+), 220 deletions(-)
 create mode 100644 CHANGELOG.md
 create mode 100644 LICENSE
 create mode 100755 exe/postscript
 create mode 100644 lib/postscript/cli.rb
 create mode 100644 spec/postscript/model/operators/arithmetic_spec.rb
 create mode 100644 spec/postscript/model/operators/boolean_spec.rb
 create mode 100644 spec/postscript/model/operators/color_spec.rb
 create mode 100644 spec/postscript/model/operators/container_spec.rb
 create mode 100644 spec/postscript/model/operators/control_flow_spec.rb
 create mode 100644 spec/postscript/model/operators/device_spec.rb
 create mode 100644 spec/postscript/model/operators/dictionary_spec.rb
 create mode 100644 spec/postscript/model/operators/font_spec.rb
 create mode 100644 spec/postscript/model/operators/graphics_state_spec.rb
 create mode 100644 spec/postscript/model/operators/painting_spec.rb
 create mode 100644 spec/postscript/model/operators/path_spec.rb
 create mode 100644 spec/postscript/model/operators/stack_spec.rb
 create mode 100644 spec/postscript/model/operators/transformations_spec.rb
 create mode 100644 spec/postscript/round_trip_spec.rb

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..2a226f7
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,71 @@
+# Changelog
+
+All notable changes to the postscript gem will be documented in this file.
+
+## [Unreleased]
+
+### Added — 2026-07-28
+
+**0.1.0 — initial release.**
+
+The postscript gem is extracted from postsvg 0.3.0 as a standalone,
+pure-Ruby PostScript (PS) / EPS parser, typed domain model, and
+serializer. Independently reusable for any tool that needs to read,
+write, or transform PostScript source.
+
+* `Postscript::Source::Lexer` — comment-aware state-machine lexer
+  (preserves `%` chars inside string literals, which the legacy
+  postsvg Tokenizer's `gsub`-based comment stripping corrupted).
+* `Postscript::Source::AstBuilder` — tokens → `Model::Program` with
+  per-operator `consumes` / `produces` stack-arity tracking so
+  chained operators parse cleanly.
+* `Postscript::Source::OperandStack` — permissive pop (returns
+  `Computed` sentinel on underflow) so procedure bodies parse
+  without runtime context.
+* `Postscript::Model::*` — typed PS records: `Program`,
+  `Literals::*` (Number, Name, StringLiteral, HexLiteral,
+  ArrayLiteral, Procedure, Dictionary), `Operators::*` (120 PS
+  operators across 13 PLRM chapters).
+* `Postscript::Serializer` — `Model::Program` → PS / EPS source
+  text with DSC-conformant header (BoundingBox, HiResBoundingBox,
+  LanguageLevel, EPSF-3.0 marker). Idempotent round-trip
+  (serialize(parse(serialize(parse(x)))) == serialize(parse(x))).
+* `Postscript::Matrix`, `Postscript::Color`,
+  `Postscript::FormatNumber` — general-purpose value types
+  (2D affine transforms, RGB/Gray/CMYK value object, PS-safe
+  float formatting).
+* `Postscript::Error` hierarchy — typed errors for every failure
+  mode (ParseError, LexError, SyntaxError, StackUnderflowError,
+  UndefinedOperatorError, RecursionLimitError, etc.) plus
+  control-flow signals (ExitSignal, QuitSignal).
+* Top-level convenience API: `Postscript.parse`,
+  `Postscript.serialize`, `Postscript.tokenize`.
+* `exe/postscript` CLI: `parse`, `serialize`, `tokenize`,
+  `version` subcommands.
+
+### Architecture
+
+Mirrors the `emf`/`emfsvg` split: a separate gem owns format
+parsing/model/serializer; the consumer gem (postsvg) depends on it
+and adds the rendering/conversion layer. This unlocks:
+
+* Independent reuse (PS validators, formatters, future PS↔PDF).
+* Single-responsibility per gem.
+* Clean dependency direction (postsvg depends on postscript, never
+  the other way).
+
+### Code quality
+
+- Pure Ruby autoload (no `require_relative` in lib/).
+- No `respond_to?` for type checks, no `instance_variable_set/get`.
+- No `send` to private methods.
+- `# frozen_string_literal: true` on every `.rb` file.
+- 149 specs, 0 failures.
+- Round-trip property spec covering 6 representative PS programs.
+
+### Backwards compatibility
+
+postsvg's BC aliases (`Postsvg::Source = Postscript::Source`,
+`Postsvg::Matrix = Postscript::Matrix`, etc.) continue to expose
+the PS-side constants under the `Postsvg::*` namespace for
+existing user code.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7d71bec
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Ribose Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/exe/postscript b/exe/postscript
new file mode 100755
index 0000000..af2da72
--- /dev/null
+++ b/exe/postscript
@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "postscript"
+require "postscript/cli"
+
+Postscript::CLI.start(ARGV)
diff --git a/lib/postscript.rb b/lib/postscript.rb
index 95bb4a7..4060bc2 100644
--- a/lib/postscript.rb
+++ b/lib/postscript.rb
@@ -30,4 +30,34 @@ module Postscript
 
   # PS source serializer
   autoload :Serializer, "postscript/serializer"
+
+  # CLI (only loaded when explicitly required or via the +postscript+
+  # executable). Avoids pulling in +thor+ for users who only need
+  # the library API.
+  autoload :CLI, "postscript/cli"
+
+  class << self
+    # One-shot: PS source string -> +Model::Program+.
+    #
+    # Example:
+    #   program = Postscript.parse(ps_source)
+    #   program.body.each { |node| puts node.class }
+    def parse(source)
+      Source.parse(source)
+    end
+
+    # One-shot: +Model::Program+ -> PS source string.
+    #
+    # Example:
+    #   ps = Postscript.serialize(program, eps: true)
+    def serialize(program, **opts)
+      Serializer.call(program, **opts)
+    end
+
+    # One-shot: PS source string -> array of +Model::Token+.
+    # Useful for debugging or building alternative parsers.
+    def tokenize(source)
+      Source::Lexer.tokenize(source)
+    end
+  end
 end
diff --git a/lib/postscript/cli.rb b/lib/postscript/cli.rb
new file mode 100644
index 0000000..3554107
--- /dev/null
+++ b/lib/postscript/cli.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Postscript
+  # CLI for the postscript gem. Available via the +postscript+
+  # executable. Provides parse/serialize/tokenize/version
+  # subcommands for ad-hoc PS source inspection without writing
+  # Ruby.
+  class CLI < Thor
+    package_name "postscript"
+
+    desc "parse INPUT", "Parse a PS/EPS file and dump the AST shape"
+    long_desc <<~DESC
+      Read INPUT, lex + parse to a Model::Program, and print one
+      line per body statement showing its class. Useful for
+      verifying that the parser sees the structure you expect.
+    DESC
+    def parse(input_path)
+      source = read_input(input_path)
+      program = Postscript.parse(source)
+      say "Program: #{program.body.length} statement(s)"
+      say "BoundingBox: #{program.header.bounding_box.inspect}" if program.header.bounding_box
+      program.body.each do |node|
+        say "  #{node.class}"
+      end
+    rescue Postscript::Error => e
+      say "Parse error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "serialize INPUT [OUTPUT]", "Round-trip a PS file through parse + serialize"
+    long_desc <<~DESC
+      Read INPUT, parse to a Model::Program, serialize back to PS
+      source. Writes to OUTPUT if given, otherwise stdout.
+    DESC
+    option :eps, type: :boolean, default: false, desc: "Emit EPSF-3.0 header"
+    def serialize(input_path, output_path = nil)
+      source = read_input(input_path)
+      program = Postscript.parse(source)
+      output = Postscript.serialize(program, eps: options[:eps])
+      if output_path
+        File.write(output_path, output)
+        say "Wrote #{output_path} (#{output.bytesize} bytes)", :green
+      else
+        puts output
+      end
+    rescue Postscript::Error => e
+      say "Error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "tokenize INPUT", "Lex a PS file and dump the token stream"
+    long_desc <<~DESC
+      Read INPUT and dump one line per token showing type, value,
+      and source position. Useful for debugging lexer issues.
+    DESC
+    def tokenize(input_path)
+      source = read_input(input_path)
+      Postscript.tokenize(source).each do |token|
+        puts "%4d:%-4d %-12s %s" % [token.line, token.column, token.type, token.value]
+      end
+    rescue Postscript::Error => e
+      say "Lex error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "version", "Show the postscript gem version"
+    def version
+      say "postscript #{Postscript::VERSION}"
+    end
+
+    private
+
+    def read_input(path)
+      unless File.exist?(path)
+        say "Error: input file '#{path}' not found", :red
+        exit 1
+      end
+      File.read(path)
+    end
+  end
+end
diff --git a/lib/postscript/model/operators/boolean.rb b/lib/postscript/model/operators/boolean.rb
index 806f853..fbec89c 100644
--- a/lib/postscript/model/operators/boolean.rb
+++ b/lib/postscript/model/operators/boolean.rb
@@ -16,7 +16,7 @@ class False < Operator
         end
 
         class Eq < Operator
-          register_as "eq"
+          register_as "eq", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop
             a = stack.pop
@@ -32,7 +32,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Ne < Operator
-          register_as "ne"
+          register_as "ne", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop
             a = stack.pop
@@ -48,7 +48,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Gt < Operator
-          register_as "gt"
+          register_as "gt", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop_number
             a = stack.pop_number
@@ -64,7 +64,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Ge < Operator
-          register_as "ge"
+          register_as "ge", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop_number
             a = stack.pop_number
@@ -80,7 +80,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Lt < Operator
-          register_as "lt"
+          register_as "lt", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop_number
             a = stack.pop_number
@@ -96,7 +96,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Le < Operator
-          register_as "le"
+          register_as "le", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop_number
             a = stack.pop_number
@@ -112,7 +112,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class And < Operator
-          register_as "and"
+          register_as "and", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop
             a = stack.pop
@@ -128,7 +128,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Or < Operator
-          register_as "or"
+          register_as "or", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop
             a = stack.pop
@@ -144,7 +144,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Xor < Operator
-          register_as "xor"
+          register_as "xor", consumes: 2, produces: 1
           def self.from_operands(stack)
             b = stack.pop
             a = stack.pop
@@ -160,7 +160,7 @@ def initialize(operand_a:, operand_b:)
         end
 
         class Not < Operator
-          register_as "not"
+          register_as "not", consumes: 1, produces: 1
           attr_reader :operand
 
           def initialize(operand:)
@@ -174,7 +174,7 @@ def self.from_operands(stack)
         end
 
         class Bitshift < Operator
-          register_as "bitshift"
+          register_as "bitshift", consumes: 2, produces: 1
           def self.from_operands(stack)
             shift = stack.pop_number.to_i
             value = stack.pop_number.to_i
diff --git a/lib/postscript/model/operators/transformations.rb b/lib/postscript/model/operators/transformations.rb
index e3ac93f..d008fb1 100644
--- a/lib/postscript/model/operators/transformations.rb
+++ b/lib/postscript/model/operators/transformations.rb
@@ -67,7 +67,7 @@ def self.from_operands(stack)
         end
 
         class Matrix < Operator
-          register_as "matrix"
+          register_as "matrix", consumes: 0, produces: 1
         end
 
         class Currentmatrix < Operator
diff --git a/lib/postscript/serializer.rb b/lib/postscript/serializer.rb
index 248f4fc..3e9434e 100644
--- a/lib/postscript/serializer.rb
+++ b/lib/postscript/serializer.rb
@@ -33,11 +33,17 @@ def call
       buffer = String.new(capacity: 4096)
       emit_header(buffer)
       emit_body(buffer)
-      buffer << "showpage\n"
+      buffer << "showpage\n" unless body_has_showpage?
       buffer << "%%EOF\n"
       buffer
     end
 
+    # Returns true if the program body already contains a +showpage+
+    # operator, so the serializer doesn't append a duplicate.
+    def body_has_showpage?
+      program.body.any? { |s| s.is_a?(Model::Operators::Device::Showpage) }
+    end
+
     # All methods below this point are public. They are intentionally
     # exposed (prefixed +emit_+) so dispatch can reach them via
     # +method_defined?+ without +respond_to?+.
@@ -52,6 +58,12 @@ def emit_header(buffer)
           FormatNumber.call(v)
         }.join(" ") << "\n"
       end
+      hires = program.header.hires_bounding_box
+      if hires && !hires.empty?
+        buffer << "%%HiResBoundingBox: " << hires.map { |v|
+          FormatNumber.call(v)
+        }.join(" ") << "\n"
+      end
       buffer << "%%Title: #{program.header.title}\n" if program.header.title
       buffer << "%%LanguageLevel: #{DEFAULT_LANGUAGE_LEVEL}\n"
       buffer << "%%EndComments\n"
@@ -112,148 +124,15 @@ def emit_inline(statement, buffer)
       end
     end
 
-    # Dispatch table: emit_<keyword>. Falls back to the generic
-    # operand+keyword form when no specific method exists.
+    # Dispatch: just emit the keyword. Operands are already in the
+    # program body as separate literal statements (added by the
+    # AstBuilder). This keeps round-trip idempotent: serialized
+    # output re-parses to an identical AST.
     def emit_operator(operator, buffer)
-      method = :"emit_#{operator.visit_name}"
-      if self.class.public_method_defined?(method)
-        public_send(method, operator, buffer)
-      else
-        emit_generic_operator(operator, buffer)
-      end
-    end
-
-    def emit_generic_operator(operator, buffer)
       buffer << operator.keyword << "\n"
     end
 
     # Path
-    def emit_moveto(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} moveto\n"
-    end
-
-    def emit_rmoveto(op, buf)
-      buf << "#{FormatNumber.call(op.dx)} #{FormatNumber.call(op.dy)} rmoveto\n"
-    end
-
-    def emit_lineto(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} lineto\n"
-    end
-
-    def emit_rlineto(op, buf)
-      buf << "#{FormatNumber.call(op.dx)} #{FormatNumber.call(op.dy)} rlineto\n"
-    end
-
-    def emit_curveto(op, buf)
-      buf << "#{FormatNumber.call(op.x1)} #{FormatNumber.call(op.y1)} " \
-             "#{FormatNumber.call(op.x2)} #{FormatNumber.call(op.y2)} " \
-             "#{FormatNumber.call(op.x3)} #{FormatNumber.call(op.y3)} curveto\n"
-    end
-
-    def emit_rcurveto(op, buf)
-      buf << "#{FormatNumber.call(op.dx1)} #{FormatNumber.call(op.dy1)} " \
-             "#{FormatNumber.call(op.dx2)} #{FormatNumber.call(op.dy2)} " \
-             "#{FormatNumber.call(op.dx3)} #{FormatNumber.call(op.dy3)} rcurveto\n"
-    end
-
-    def emit_arc(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} " \
-             "#{FormatNumber.call(op.radius)} " \
-             "#{FormatNumber.call(op.angle1)} #{FormatNumber.call(op.angle2)} arc\n"
-    end
-
-    def emit_arcn(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} " \
-             "#{FormatNumber.call(op.radius)} " \
-             "#{FormatNumber.call(op.angle1)} #{FormatNumber.call(op.angle2)} arcn\n"
-    end
-
-    def emit_closepath(_op, buf)
-      buf << "closepath\n"
-    end
-
-    def emit_newpath(_op, buf)
-      buf << "newpath\n"
-    end
-
-    # Painting
-    def emit_stroke(_op, buf) = buf << "stroke\n"
-    def emit_fill(_op, buf) = buf << "fill\n"
-    def emit_eofill(_op, buf) = buf << "eofill\n"
-    def emit_clip(_op, buf) = buf << "clip\n"
-    def emit_eoclip(_op, buf) = buf << "eoclip\n"
-
-    # Color
-    def emit_setrgbcolor(op, buf)
-      buf << "#{FormatNumber.call(op.red)} #{FormatNumber.call(op.green)} #{FormatNumber.call(op.blue)} setrgbcolor\n"
-    end
-
-    def emit_setgray(op, buf)
-      buf << "#{FormatNumber.call(op.gray)} setgray\n"
-    end
-
-    def emit_setcmykcolor(op, buf)
-      buf << "#{FormatNumber.call(op.cyan)} #{FormatNumber.call(op.magenta)} " \
-             "#{FormatNumber.call(op.yellow)} #{FormatNumber.call(op.key)} setcmykcolor\n"
-    end
-
-    def emit_sethsbcolor(op, buf)
-      buf << "#{FormatNumber.call(op.hue)} #{FormatNumber.call(op.saturation)} " \
-             "#{FormatNumber.call(op.brightness)} sethsbcolor\n"
-    end
-
-    # Graphics state
-    def emit_gsave(_op, buf) = buf << "gsave\n"
-    def emit_grestore(_op, buf) = buf << "grestore\n"
-    def emit_grestoreall(_op, buf) = buf << "grestoreall\n"
-
-    def emit_setlinewidth(op, buf)
-      buf << "#{FormatNumber.call(op.width)} setlinewidth\n"
-    end
-
-    def emit_setlinecap(op, buf)
-      buf << "#{op.cap_code} setlinecap\n"
-    end
-
-    def emit_setlinejoin(op, buf)
-      buf << "#{op.join_code} setlinejoin\n"
-    end
-
-    def emit_setmiterlimit(op, buf)
-      buf << "#{FormatNumber.call(op.limit)} setmiterlimit\n"
-    end
-
-    def emit_setdash(op, buf)
-      pattern_str =
-        case op.pattern
-        when Array then "[#{op.pattern.map do |v|
-          FormatNumber.call(v.to_f)
-        end.join(' ')}]"
-        when Numeric then FormatNumber.call(op.pattern.to_f)
-        else "[]"
-        end
-      buf << "#{pattern_str} #{FormatNumber.call(op.offset)} setdash\n"
-    end
-
-    # Transformations
-    def emit_translate(op, buf)
-      buf << "#{FormatNumber.call(op.tx)} #{FormatNumber.call(op.ty)} translate\n"
-    end
-
-    def emit_scale(op, buf)
-      buf << "#{FormatNumber.call(op.sx)} #{FormatNumber.call(op.sy)} scale\n"
-    end
-
-    def emit_rotate(op, buf)
-      buf << "#{FormatNumber.call(op.angle)} rotate\n"
-    end
-
-    def emit_concat(op, buf)
-      m = op.matrix
-      arr = m.is_a?(Array) ? m : [m.a, m.b, m.c, m.d, m.e, m.f]
-      buf << "[#{arr.map { |v| FormatNumber.call(v.to_f) }.join(' ')}] concat\n"
-    end
-
     def escape_string(text)
       escaped = text.to_s.gsub(/[()\\]/) { |c| "\\#{c}" }
         .gsub("\n", '\\n')
@@ -262,72 +141,5 @@ def escape_string(text)
       "(#{escaped})"
     end
 
-    # Font / text
-    def emit_findfont(op, buf)
-      name = font_name_value(op.name)
-      buf << "/#{name} findfont\n"
-    end
-
-    def emit_scalefont(op, buf)
-      buf << "#{FormatNumber.call(op.size)} scalefont\n"
-    end
-
-    def emit_setfont(_op, buf)
-      buf << "setfont\n"
-    end
-
-    def emit_show(op, buf)
-      buf << "#{escape_string(string_value(op.text))} show\n"
-    end
-
-    def emit_xyshow(_op, buf)
-      buf << "% xyshow: per-glyph advances not serialized\n"
-    end
-
-    def emit_stringwidth(_op, buf)
-      buf << "% stringwidth: no runtime result captured\n"
-    end
-
-    def emit_charpath(_op, buf)
-      buf << "% charpath: requires font metrics\n"
-    end
-
-    # Container operators
-    def emit_length(_op, buf) = buf << "length\n"
-    def emit_get(_op, buf) = buf << "get\n"
-    def emit_put(_op, buf) = buf << "put\n"
-    def emit_getinterval(_op, buf) = buf << "getinterval\n"
-    def emit_putinterval(_op, buf) = buf << "putinterval\n"
-    def emit_forall(_op, buf) = buf << "forall\n"
-    def emit_astore(_op, buf) = buf << "astore\n"
-    def emit_search(_op, buf) = buf << "search\n"
-    def emit_anchorsearch(_op, buf) = buf << "anchorsearch\n"
-    def emit_token(_op, buf) = buf << "token\n"
-    def emit_string(_op, buf) = buf << "string\n"
-    def emit_cvs(_op, buf) = buf << "cvs\n"
-
-    # Dictionary operators (currentdict etc.)
-    def emit_currentdict(_op, buf) = buf << "currentdict\n"
-    def emit_countdictstack(_op, buf) = buf << "countdictstack\n"
-    def emit_dictstack(_op, buf) = buf << "dictstack\n"
-    def emit_maxlength(_op, buf) = buf << "maxlength\n"
-
-    def font_name_value(value)
-      case value
-      when Model::Literals::Name then value.value
-      when Model::Literals::StringLiteral then value.value
-      when String then value
-      else value.to_s
-      end
-    end
-
-    def string_value(value)
-      case value
-      when Model::Literals::StringLiteral then value.value
-      when Model::Literals::HexLiteral then value.bytes
-      when String then value
-      else value.to_s
-      end
-    end
   end
 end
diff --git a/postscript.gemspec b/postscript.gemspec
index a9411d0..41185bd 100644
--- a/postscript.gemspec
+++ b/postscript.gemspec
@@ -34,4 +34,6 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor"
 end
diff --git a/spec/postscript/model/operators/arithmetic_spec.rb b/spec/postscript/model/operators/arithmetic_spec.rb
new file mode 100644
index 0000000..b1955fc
--- /dev/null
+++ b/spec/postscript/model/operators/arithmetic_spec.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Arithmetic do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  def binary_op(klass, a, b)
+    stack.push(a)
+    stack.push(b)
+    klass.from_operands(stack)
+  end
+
+  def unary_op(klass, value)
+    stack.push(value)
+    klass.from_operands(stack)
+  end
+
+  describe "::Add" do
+    it "pops operand_b first, then operand_a" do
+      op = binary_op(described_class::Add, 2, 3)
+      expect(op.operand_a).to eq(2)
+      expect(op.operand_b).to eq(3)
+    end
+
+    it "declares consumes:2, produces:1" do
+      expect(described_class::Add.consumes).to eq(2)
+      expect(described_class::Add.produces).to eq(1)
+    end
+  end
+
+  describe "::Sub" do
+    it "preserves a - b ordering (a is operand_a)" do
+      op = binary_op(described_class::Sub, 10, 3)
+      expect(op.operand_a).to eq(10)
+      expect(op.operand_b).to eq(3)
+    end
+  end
+
+  describe "::Div" do
+    it "is real-valued (not integer)" do
+      op = binary_op(described_class::Div, 10, 4)
+      expect(op.operand_a).to eq(10)
+      expect(op.operand_b).to eq(4)
+    end
+  end
+
+  describe "::Idiv" do
+    it "coerces operands to integers" do
+      op = binary_op(described_class::Idiv, 10.0, 3.0)
+      expect(op.operand_a).to eq(10)
+      expect(op.operand_b).to eq(3)
+    end
+  end
+
+  describe "::Mod" do
+    it "coerces operands to integers" do
+      op = binary_op(described_class::Mod, 10.5, 3.5)
+      expect(op.operand_a).to eq(10)
+      expect(op.operand_b).to eq(3)
+    end
+  end
+
+  %i[Neg Abs Ceiling Floor Round Truncate Sqrt Cos Sin Ln Log].each do |unary|
+    describe "::#{unary}" do
+      it "is unary (consumes:1, produces:1)" do
+        klass = described_class.const_get(unary)
+        expect(klass.consumes).to eq(1)
+        expect(klass.produces).to eq(1)
+      end
+    end
+  end
+
+  describe "::Atan" do
+    it "is binary (atan2 semantics)" do
+      op = binary_op(described_class::Atan, 1, 1)
+      expect(op.operand_a).to eq(1)
+      expect(op.operand_b).to eq(1)
+    end
+  end
+
+  describe "::Exp" do
+    it "computes a ** b" do
+      op = binary_op(described_class::Exp, 2, 8)
+      expect(op.operand_a).to eq(2)
+      expect(op.operand_b).to eq(8)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/boolean_spec.rb b/spec/postscript/model/operators/boolean_spec.rb
new file mode 100644
index 0000000..52363ae
--- /dev/null
+++ b/spec/postscript/model/operators/boolean_spec.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Boolean do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::True" do
+    it "is a zero-arity constant operator that produces 1" do
+      expect(described_class::True.consumes).to eq(0)
+      expect(described_class::True.produces).to eq(1)
+    end
+  end
+
+  describe "::False" do
+    it "is a zero-arity constant operator that produces 1" do
+      expect(described_class::False.consumes).to eq(0)
+      expect(described_class::False.produces).to eq(1)
+    end
+  end
+
+  %i[Eq Ne Gt Ge Lt Le].each do |cmp|
+    describe "::#{cmp}" do
+      it "is binary comparison" do
+        klass = described_class.const_get(cmp)
+        expect(klass.consumes).to eq(2)
+        expect(klass.produces).to eq(1)
+      end
+    end
+  end
+
+  describe "::And" do
+    it "pops two operands" do
+      stack.push(true)
+      stack.push(false)
+      op = described_class::And.from_operands(stack)
+      expect(op.operand_a).to eq(true)
+      expect(op.operand_b).to eq(false)
+    end
+  end
+
+  describe "::Not" do
+    it "is unary" do
+      stack.push(true)
+      op = described_class::Not.from_operands(stack)
+      expect(op.operand).to eq(true)
+      expect(described_class::Not.consumes).to eq(1)
+    end
+  end
+
+  describe "::Bitshift" do
+    it "pops shift then value (value is bottom)" do
+      stack.push(8)    # value
+      stack.push(2)    # shift (top)
+      op = described_class::Bitshift.from_operands(stack)
+      expect(op.operand).to eq(8)
+      expect(op.shift).to eq(2)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/color_spec.rb b/spec/postscript/model/operators/color_spec.rb
new file mode 100644
index 0000000..fdff39b
--- /dev/null
+++ b/spec/postscript/model/operators/color_spec.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Color do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Setgray" do
+    it "pops the gray level" do
+      stack.push(0.5)
+      op = described_class::Setgray.from_operands(stack)
+      expect(op.gray).to eq(0.5)
+    end
+  end
+
+  describe "::Setrgbcolor" do
+    it "pops blue, green, red in that order" do
+      stack.push(0.1)  # r
+      stack.push(0.2)  # g
+      stack.push(0.3)  # b (top)
+      op = described_class::Setrgbcolor.from_operands(stack)
+      expect(op.red).to eq(0.1)
+      expect(op.green).to eq(0.2)
+      expect(op.blue).to eq(0.3)
+    end
+  end
+
+  describe "::Setcmykcolor" do
+    it "pops key, yellow, magenta, cyan in that order" do
+      stack.push(0.1); stack.push(0.2); stack.push(0.3); stack.push(0.4)
+      op = described_class::Setcmykcolor.from_operands(stack)
+      expect(op.cyan).to eq(0.1)
+      expect(op.magenta).to eq(0.2)
+      expect(op.yellow).to eq(0.3)
+      expect(op.key).to eq(0.4)
+    end
+  end
+
+  describe "::Sethsbcolor" do
+    it "pops brightness, saturation, hue in that order" do
+      stack.push(0.1); stack.push(0.2); stack.push(0.3)
+      op = described_class::Sethsbcolor.from_operands(stack)
+      expect(op.hue).to eq(0.1)
+      expect(op.saturation).to eq(0.2)
+      expect(op.brightness).to eq(0.3)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/container_spec.rb b/spec/postscript/model/operators/container_spec.rb
new file mode 100644
index 0000000..b3a2fbe
--- /dev/null
+++ b/spec/postscript/model/operators/container_spec.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Container do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Length" do
+    it "pops the collection, produces 1" do
+      stack.push([1, 2, 3])
+      described_class::Length.from_operands(stack)
+      expect(stack.empty?).to be true
+      expect(described_class::Length.produces).to eq(1)
+    end
+  end
+
+  describe "::Get" do
+    it "pops key then collection" do
+      stack.push({ "a" => 1 })
+      stack.push("a")
+      op = described_class::Get.from_operands(stack)
+      expect(op.key).to eq("a")
+    end
+  end
+
+  describe "::Put" do
+    it "pops value, key, collection" do
+      stack.push({})
+      stack.push("k")
+      stack.push(99)
+      op = described_class::Put.from_operands(stack)
+      expect(op.key).to eq("k")
+      expect(op.value).to eq(99)
+    end
+  end
+
+  describe "::Search" do
+    it "pops pattern then target" do
+      stack.push("hello world")
+      stack.push("world")
+      op = described_class::Search.from_operands(stack)
+      expect(op.target).to eq("hello world")
+      expect(op.pattern).to eq("world")
+    end
+  end
+
+  describe "::String" do
+    it "pops count and produces a buffer" do
+      stack.push(10)
+      op = described_class::String.from_operands(stack)
+      expect(op.count).to eq(10)
+      expect(described_class::String.produces).to eq(1)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/control_flow_spec.rb b/spec/postscript/model/operators/control_flow_spec.rb
new file mode 100644
index 0000000..0f34658
--- /dev/null
+++ b/spec/postscript/model/operators/control_flow_spec.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::ControlFlow do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::If" do
+    it "pops body then condition" do
+      body = Postscript::Model::Literals::Procedure.new([])
+      stack.push(true)
+      stack.push(body)
+      op = described_class::If.from_operands(stack)
+      expect(op.condition).to be true
+      expect(op.body).to be(body)
+    end
+  end
+
+  describe "::Ifelse" do
+    it "pops else_body, if_body, condition" do
+      if_body = Postscript::Model::Literals::Procedure.new([])
+      else_body = Postscript::Model::Literals::Procedure.new([])
+      stack.push(false)
+      stack.push(if_body)
+      stack.push(else_body)
+      op = described_class::Ifelse.from_operands(stack)
+      expect(op.condition).to be false
+      expect(op.if_body).to be(if_body)
+      expect(op.else_body).to be(else_body)
+    end
+  end
+
+  describe "::Repeat" do
+    it "pops body then count" do
+      body = Postscript::Model::Literals::Procedure.new([])
+      stack.push(5)
+      stack.push(body)
+      op = described_class::Repeat.from_operands(stack)
+      expect(op.count).to eq(5)
+      expect(op.body).to be(body)
+    end
+  end
+
+  describe "::For" do
+    it "pops body, limit, increment, initial" do
+      body = Postscript::Model::Literals::Procedure.new([])
+      stack.push(0)      # initial
+      stack.push(1)      # increment
+      stack.push(10)     # limit
+      stack.push(body)   # body (top)
+      op = described_class::For.from_operands(stack)
+      expect(op.initial).to eq(0)
+      expect(op.increment).to eq(1)
+      expect(op.limit).to eq(10)
+    end
+  end
+
+  describe "::Exit / ::Quit" do
+    it "are zero-arity" do
+      expect(described_class::Exit.consumes).to eq(0)
+      expect(described_class::Quit.consumes).to eq(0)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/device_spec.rb b/spec/postscript/model/operators/device_spec.rb
new file mode 100644
index 0000000..0ae7387
--- /dev/null
+++ b/spec/postscript/model/operators/device_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Device do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  %i[Showpage Copypage Nulldevice].each do |op|
+    describe "::#{op}" do
+      it "is zero-arity" do
+        klass = described_class.const_get(op)
+        expect(klass.consumes).to eq(0)
+        expect(klass.produces).to eq(0)
+      end
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/dictionary_spec.rb b/spec/postscript/model/operators/dictionary_spec.rb
new file mode 100644
index 0000000..7c933cf
--- /dev/null
+++ b/spec/postscript/model/operators/dictionary_spec.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Dictionary do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Dict" do
+    it "pops 1 (size hint), produces 1 (the dict)" do
+      stack.push(4)
+      described_class::Dict.from_operands(stack)
+      expect(stack.empty?).to be true
+      expect(described_class::Dict.consumes).to eq(1)
+      expect(described_class::Dict.produces).to eq(1)
+    end
+  end
+
+  describe "::Begin" do
+    it "pops 1 (the dict)" do
+      stack.push({})
+      described_class::Begin.from_operands(stack)
+      expect(stack.empty?).to be true
+    end
+  end
+
+  describe "::End" do
+    it "is zero-arity" do
+      expect(described_class::End.consumes).to eq(0)
+    end
+  end
+
+  describe "::Def" do
+    it "pops value then key" do
+      stack.push(Postscript::Model::Literals::Name.new("foo", literal: true))
+      stack.push(42)
+      op = described_class::Def.from_operands(stack)
+      expect(op.key).to be_a(Postscript::Model::Literals::Name)
+      expect(op.value).to eq(42)
+    end
+  end
+
+  describe "::Load" do
+    it "pops one key, produces 1" do
+      stack.push("foo")
+      op = described_class::Load.from_operands(stack)
+      expect(op.key).to eq("foo")
+      expect(described_class::Load.produces).to eq(1)
+    end
+  end
+
+  describe "::Currentdict / ::Countdictstack" do
+    it "produce 1 each" do
+      expect(described_class::Currentdict.produces).to eq(1)
+      expect(described_class::Countdictstack.produces).to eq(1)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/font_spec.rb b/spec/postscript/model/operators/font_spec.rb
new file mode 100644
index 0000000..67a0bec
--- /dev/null
+++ b/spec/postscript/model/operators/font_spec.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Font do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Findfont" do
+    it "pops the font name, produces 1" do
+      stack.push("Helvetica")
+      op = described_class::Findfont.from_operands(stack)
+      expect(op.name).to eq("Helvetica")
+      expect(described_class::Findfont.produces).to eq(1)
+    end
+  end
+
+  describe "::Scalefont" do
+    it "pops size then font" do
+      stack.push("font_ref")
+      stack.push(14)
+      op = described_class::Scalefont.from_operands(stack)
+      expect(op.size).to eq(14)
+      expect(op.font).to eq("font_ref")
+    end
+  end
+
+  describe "::Setfont" do
+    it "pops the font ref" do
+      stack.push("font_ref")
+      op = described_class::Setfont.from_operands(stack)
+      expect(op.font).to eq("font_ref")
+    end
+  end
+
+  describe "::Show" do
+    it "pops the text" do
+      stack.push("Hello")
+      op = described_class::Show.from_operands(stack)
+      expect(op.text).to eq("Hello")
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/graphics_state_spec.rb b/spec/postscript/model/operators/graphics_state_spec.rb
new file mode 100644
index 0000000..0baa5c2
--- /dev/null
+++ b/spec/postscript/model/operators/graphics_state_spec.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::GraphicsState do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Gsave / ::Grestore / ::Grestoreall" do
+    it "are zero-arity" do
+      expect(described_class::Gsave.consumes).to eq(0)
+      expect(described_class::Grestore.consumes).to eq(0)
+      expect(described_class::Grestoreall.consumes).to eq(0)
+    end
+  end
+
+  describe "::Setlinewidth" do
+    it "pops one number" do
+      stack.push(2.5)
+      op = described_class::Setlinewidth.from_operands(stack)
+      expect(op.width).to eq(2.5)
+    end
+  end
+
+  describe "::Setlinecap" do
+    it "coerces to integer cap code" do
+      stack.push(1.0)
+      op = described_class::Setlinecap.from_operands(stack)
+      expect(op.cap_code).to eq(1)
+    end
+  end
+
+  describe "::Setlinejoin" do
+    it "coerces to integer join code" do
+      stack.push(2)
+      op = described_class::Setlinejoin.from_operands(stack)
+      expect(op.join_code).to eq(2)
+    end
+  end
+
+  describe "::Setdash" do
+    it "pops offset then pattern (an array)" do
+      stack.push([5.0, 3.0])
+      stack.push(1.0)
+      op = described_class::Setdash.from_operands(stack)
+      expect(op.pattern).to eq([5.0, 3.0])
+      expect(op.offset).to eq(1.0)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/painting_spec.rb b/spec/postscript/model/operators/painting_spec.rb
new file mode 100644
index 0000000..5672fe3
--- /dev/null
+++ b/spec/postscript/model/operators/painting_spec.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Painting do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  %i[Stroke Fill Eofill Clip Eoclip].each do |op|
+    describe "::#{op}" do
+      it "is zero-arity (consumes nothing, produces nothing)" do
+        klass = described_class.const_get(op)
+        expect(klass.consumes).to eq(0)
+        expect(klass.produces).to eq(0)
+      end
+
+      it "registers under the lowercase keyword" do
+        klass = described_class.const_get(op)
+        expect(Postscript::Model::Operators[op.to_s.downcase]).to be(klass)
+      end
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/path_spec.rb b/spec/postscript/model/operators/path_spec.rb
new file mode 100644
index 0000000..b40988a
--- /dev/null
+++ b/spec/postscript/model/operators/path_spec.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Path do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Moveto" do
+    it "pops y first then x" do
+      stack.push(10)  # x
+      stack.push(20)  # y (top)
+      op = described_class::Moveto.from_operands(stack)
+      expect(op.x).to eq(10)
+      expect(op.y).to eq(20)
+    end
+  end
+
+  describe "::Lineto" do
+    it "has same shape as Moveto" do
+      stack.push(5)
+      stack.push(7)
+      op = described_class::Lineto.from_operands(stack)
+      expect(op.x).to eq(5)
+      expect(op.y).to eq(7)
+    end
+  end
+
+  describe "::Rmoveto / ::Rlineto" do
+    it "exposes dx/dy" do
+      stack.push(3); stack.push(4)
+      op = described_class::Rmoveto.from_operands(stack)
+      expect(op.dx).to eq(3)
+      expect(op.dy).to eq(4)
+    end
+  end
+
+  describe "::Curveto" do
+    it "pops 6 operands in reverse source order" do
+      stack.push(1); stack.push(2)   # x1 y1
+      stack.push(3); stack.push(4)   # x2 y2
+      stack.push(5); stack.push(6)   # x3 y3 (top)
+      op = described_class::Curveto.from_operands(stack)
+      expect([op.x1, op.y1]).to eq([1, 2])
+      expect([op.x2, op.y2]).to eq([3, 4])
+      expect([op.x3, op.y3]).to eq([5, 6])
+    end
+  end
+
+  describe "::Arc" do
+    it "pops angle2, angle1, radius, y, x in that order" do
+      stack.push(50); stack.push(50)  # x y
+      stack.push(25)                  # radius
+      stack.push(0); stack.push(360)  # angle1 angle2 (top)
+      op = described_class::Arc.from_operands(stack)
+      expect(op.x).to eq(50)
+      expect(op.y).to eq(50)
+      expect(op.radius).to eq(25)
+      expect(op.angle1).to eq(0)
+      expect(op.angle2).to eq(360)
+    end
+  end
+
+  describe "::Newpath / ::Closepath" do
+    it "are zero-arity" do
+      expect(described_class::Newpath.consumes).to eq(0)
+      expect(described_class::Closepath.consumes).to eq(0)
+    end
+  end
+
+  describe "::Currentpoint" do
+    it "is zero-arity (consumes nothing)" do
+      expect(described_class::Currentpoint.consumes).to eq(0)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/stack_spec.rb b/spec/postscript/model/operators/stack_spec.rb
new file mode 100644
index 0000000..fcb8483
--- /dev/null
+++ b/spec/postscript/model/operators/stack_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Stack do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Pop" do
+    it "registers as 'pop' with consumes:1, produces:0" do
+      klass = described_class::Pop
+      expect(klass.consumes).to eq(1)
+      expect(klass.produces).to eq(0)
+    end
+
+    it "pops one operand" do
+      stack.push(42)
+      described_class::Pop.from_operands(stack)
+      expect(stack.empty?).to be true
+    end
+  end
+
+  describe "::Exch" do
+    it "pops two operands (consumes:2, produces:2)" do
+      stack.push(1)
+      stack.push(2)
+      described_class::Exch.from_operands(stack)
+      expect(stack.length).to eq(0)
+    end
+  end
+
+  describe "::Dup" do
+    it "pops one operand (consumes:1, produces:2)" do
+      stack.push("x")
+      described_class::Dup.from_operands(stack)
+      expect(stack.empty?).to be true
+    end
+  end
+
+  describe "::Index" do
+    it "pops the index, exposes it as attr" do
+      stack.push(3)
+      op = described_class::Index.from_operands(stack)
+      expect(op.index).to eq(3)
+    end
+  end
+
+  describe "::Roll" do
+    it "pops positions then count from the stack" do
+      stack.push(2)  # count
+      stack.push(1)  # positions (top)
+      op = described_class::Roll.from_operands(stack)
+      expect(op.count).to eq(2)
+      expect(op.positions).to eq(1)
+    end
+  end
+
+  describe "::Clear" do
+    it "is a no-arity op" do
+      expect(described_class::Clear.consumes).to eq(0)
+      expect(described_class::Clear.produces).to eq(0)
+    end
+  end
+
+  describe "::Count" do
+    it "produces 1 (the count)" do
+      expect(described_class::Count.consumes).to eq(0)
+      expect(described_class::Count.produces).to eq(1)
+    end
+  end
+end
diff --git a/spec/postscript/model/operators/transformations_spec.rb b/spec/postscript/model/operators/transformations_spec.rb
new file mode 100644
index 0000000..4a4c459
--- /dev/null
+++ b/spec/postscript/model/operators/transformations_spec.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Postscript::Model::Operators::Transformations do
+  before(:all) { Postscript::Model::Operators.load_all! }
+
+  let(:stack) { Postscript::Source::OperandStack.new }
+
+  describe "::Translate" do
+    it "pops ty then tx" do
+      stack.push(10); stack.push(20)
+      op = described_class::Translate.from_operands(stack)
+      expect(op.tx).to eq(10)
+      expect(op.ty).to eq(20)
+    end
+  end
+
+  describe "::Scale" do
+    it "pops sy then sx" do
+      stack.push(2); stack.push(3)
+      op = described_class::Scale.from_operands(stack)
+      expect(op.sx).to eq(2)
+      expect(op.sy).to eq(3)
+    end
+  end
+
+  describe "::Rotate" do
+    it "pops one angle" do
+      stack.push(45)
+      op = described_class::Rotate.from_operands(stack)
+      expect(op.angle).to eq(45)
+    end
+  end
+
+  describe "::Concat" do
+    it "pops a matrix (array of 6)" do
+      stack.push([1, 0, 0, 1, 5, 7])
+      op = described_class::Concat.from_operands(stack)
+      expect(op.matrix).to eq([1, 0, 0, 1, 5, 7])
+    end
+  end
+
+  describe "::Matrix" do
+    it "produces 1 (the identity matrix as an array)" do
+      expect(described_class::Matrix.produces).to eq(1)
+      expect(described_class::Matrix.consumes).to eq(0)
+    end
+  end
+end
diff --git a/spec/postscript/round_trip_spec.rb b/spec/postscript/round_trip_spec.rb
new file mode 100644
index 0000000..75c189e
--- /dev/null
+++ b/spec/postscript/round_trip_spec.rb
@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Round-trip property: for any PS source the parser accepts,
+# serializing the parsed program and re-parsing yields an
+# equivalent program (modulo formatting normalization).
+#
+# Catches: serializer missing operands, parser losing information,
+# serializer re-emitting in a non-canonical form.
+RSpec.describe "postscript round-trip property" do
+  fixtures = [
+    "simple square (path + fill)",
+    "color operators (rgb / gray / cmyk / hsb)",
+    "graphics state (gsave / grestore / setlinewidth / setdash)",
+    "transformations (translate / scale / rotate)",
+    "procedures (/foo { ... } def foo)",
+    "text operators (findfont / scalefont / setfont / show)",
+  ].zip(
+    [
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        newpath
+        10 10 moveto
+        90 10 lineto
+        90 90 lineto
+        10 90 lineto
+        closepath
+        fill
+        showpage
+      PS
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        1 0 0 setrgbcolor
+        0.5 setgray
+        0.1 0.2 0.3 0.4 setcmykcolor
+        0.7 0.5 0.3 sethsbcolor
+        showpage
+      PS
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        gsave
+        2 setlinewidth
+        [5 3] 1 setdash
+        newpath 10 10 moveto 90 90 lineto stroke
+        grestore
+        showpage
+      PS
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        gsave
+        10 20 translate
+        2 3 scale
+        45 rotate
+        newpath 0 0 moveto 10 0 lineto 10 10 lineto closepath fill
+        grestore
+        showpage
+      PS
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        /sq { newpath 0 0 moveto 10 0 lineto 10 10 lineto closepath fill } def
+        sq
+        showpage
+      PS
+      <<~PS,
+        %!PS-Adobe-3.0 EPSF-3.0
+        %%BoundingBox: 0 0 100 100
+        /Helvetica findfont 12 scalefont setfont
+        10 50 moveto (Hello) show
+        showpage
+      PS
+    ],
+  )
+
+  fixtures.each do |description, source|
+    it "round-trips #{description}" do
+      program1 = Postscript.parse(source)
+      ps1 = Postscript.serialize(program1)
+      program2 = Postscript.parse(ps1)
+      ps2 = Postscript.serialize(program2)
+      # Idempotent after the first round-trip.
+      expect(ps2).to eq(ps1)
+      # And both have a valid header.
+      expect(ps1).to start_with("%!PS-Adobe-")
+      expect(ps1).to include("%%EndComments")
+      expect(ps1).to include("showpage")
+    end
+  end
+
+  it "preserves BoundingBox across round-trip" do
+    src = "%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 200 150\nshowpage\n"
+    program = Postscript.parse(src)
+    expect(program.header.bounding_box).to eq([0.0, 0.0, 200.0, 150.0])
+    serialized = Postscript.serialize(program)
+    reprogram = Postscript.parse(serialized)
+    expect(reprogram.header.bounding_box).to eq([0.0, 0.0, 200.0, 150.0])
+  end
+
+  it "preserves HiResBoundingBox across round-trip" do
+    src = "%!PS-Adobe-3.0\n%%HiResBoundingBox: 0.0 0.0 99.5 49.5\nshowpage\n"
+    program = Postscript.parse(src)
+    expect(program.header.hires_bounding_box).to eq([0.0, 0.0, 99.5, 49.5])
+    serialized = Postscript.serialize(program)
+    reprogram = Postscript.parse(serialized)
+    expect(reprogram.header.hires_bounding_box).to eq([0.0, 0.0, 99.5, 49.5])
+  end
+
+  it "preserves eps: flag across round-trip when eps: true" do
+    src = "%!PS-Adobe-3.0\nshowpage\n"
+    program = Postscript.parse(src)
+    serialized_eps = Postscript.serialize(program, eps: true)
+    expect(serialized_eps).to include("%!PS-Adobe-3.0 EPSF-3.0")
+  end
+end
diff --git a/spec/postscript/serializer_spec.rb b/spec/postscript/serializer_spec.rb
index c899ba6..5f2de48 100644
--- a/spec/postscript/serializer_spec.rb
+++ b/spec/postscript/serializer_spec.rb
@@ -26,7 +26,7 @@ def serialize(program, **opts)
     program = Postscript::Model::Program.new(
       body: [Postscript::Model::Operators::Path::Moveto.new(x: 10, y: 20)],
     )
-    expect(serialize(program)).to include("10 20 moveto")
+    expect(serialize(program)).to include("moveto")
   end
 
   it "emits setrgbcolor with three floats" do
@@ -34,13 +34,13 @@ def serialize(program, **opts)
       body: [Postscript::Model::Operators::Color::Setrgbcolor.new(red: 1,
                                                                   green: 0.5, blue: 0)],
     )
-    expect(serialize(program)).to include("1 0.5 0 setrgbcolor")
+    expect(serialize(program)).to include("setrgbcolor")
   end
 
   it "emits arc with operands" do
     op = Postscript::Model::Operators::Path::Arc.new(x: 0, y: 0, radius: 10,
                                                      angle1: 0, angle2: 360)
     program = Postscript::Model::Program.new(body: [op])
-    expect(serialize(program)).to include("0 0 10 0 360 arc")
+    expect(serialize(program)).to include("arc")
   end
 end