sevgi 0.95.0 → 0.98.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47a098e5eabd1f185ef25e4d5797d347db21ccf9bddcb0dea480f921115cc129
-  data.tar.gz: 1bc7cac24e7ab2771d670edaaf4e4323a454c7a331a2663e812df3d9a1868a82
+  metadata.gz: 637d6a0c7a281ad8f1800c9fcf08968266c0e6c6a73a0ad6206a7b41e5c57fc5
+  data.tar.gz: b01598c764d715a4b381a90a3a6d5de203695459147142575cbd326ce176a07b
 SHA512:
-  metadata.gz: 6e9b877a8a87ab2493b64bd3a4e3bba4b718697e47fe860b3c98bc40db29271d9b1700113657e627cdb6e0810efc109f73b8e23ef1eb582d8976f7ab2ec8889f
-  data.tar.gz: 05d88614f5030aafcf8ce3f8e05f738decf86614ade78eae319c348d9402c4db1d7657a2743cf4f2f84f2b31f21fdf39f7bf9fef6e4078257d90aa24c9b86140
+  metadata.gz: e0c7c633c134254b8eedd6f9d8da45530f4485b0e0b3508ce1e4b76522eca83d3de456a53e956cdba3c38f48fd38e811db70d25b3fb8ed44f4c6c0261319b500
+  data.tar.gz: b9182c6a0a4d250d0f1947bcf3b8c9e7b3bcebe9268e581d59cb2db4230315eadcf511e6880bd388a74847f441bbf5b0fcf4e37889ddfbc8c7ee7094e124a971

data/CHANGELOG.md

@@ -5,6 +5,131 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## Unreleased
 
+## 0.98.2 - 2026-07-25
+
+### Fixed
+
+- Restored the `sevgi` CLI's main-object scope so bare toolkit calls remain available inside script helper classes.
+
+## 0.98.1 - 2026-07-20
+
+### Changed
+
+- Changed the `sevgi` CLI to use the executor's isolated scope by default.
+
+### Removed
+
+- Removed the redundant `-n` and `--nomain` CLI options; library consumers can still select `main: true` through
+  `Sevgi.execute` and `Sevgi.execute_file` when needed.
+
+## 0.98.0 - 2026-07-20
+
+### Added
+
+- Added standard-input support to `sevgi`, `igves`, and `igsev`; `sevgi --as NAME` and
+  `Sevgi.execute_file(..., as: NAME)` supply the logical source basename used by implicit SVG, PDF, and PNG
+  destinations without changing physical load identity.
+
+## 0.97.0 - 2026-07-19
+
+### Added
+
+- Added `sevgi-appendix`, containing the Sevgi agent skill and a RuboCop plugin for preserving readable `.sevgi` DSL
+  source alongside rubyfmt-formatted Ruby; the umbrella `sevgi` gem installs the matching Appendix version.
+- Added `sevgi --skill` to report the validated path of the matching packaged agent skill for product-neutral setup.
+- Added `igsev` to the umbrella gem for normalizing an SVG file through a complete SVG-to-Sevgi-to-SVG round trip.
+
+### Changed
+
+- Made Homebrew the recommended complete CLI installation while retaining Bundler and focused component gems for Ruby
+  application dependencies.
+
+## 0.96.0 - 2026-07-18
+
+### Added
+
+- Added exact, subtree-wide attribute omission to Derender content/file conversion, evaluation, and inclusion APIs;
+  `igves --omit` exposes the same behavior from the command line.
+- Added `Sevgi.SVG` as the explicit namespaced form of the top-level SVG document entrypoint.
+- Added the opt-in recursive `SVG::Modules` contract for callable drawing namespaces.
+- Added callable drawing-module `base` blocks, document and paper registry introspection, Canvas structural equality,
+  renderer options on `RenderChildren`, axis translation helpers, and a CC BY RDF helper.
+- Formalized non-rendering `-` metadata and `+` attribute updates as `Attributes::META_PREFIX` and
+  `Attributes::UPDATE_SUFFIX`; repeated Array updates now concatenate into a stable flat value.
+
+### Changed
+
+- Breaking: replaced the `SVG = Sevgi::Graphics` alias with an independent SVG facade. Facade operations now use
+  capitalized names such as `SVG.Canvas` and `SVG.Document`; lowercase component helpers remain on
+  `Sevgi::Graphics`, and the stuttering `SVG.SVG` form was removed.
+- Breaking: made low-level `Executor.execute` and `execute_file` runners private; consumers use
+  `Sevgi.execute` and `Sevgi.execute_file` while retaining the public result and error types.
+- Breaking: removed the abstract `Document::Base` layer from the selectable document-profile registry; `Minimal` and
+  `Default` are now sibling concrete profiles, and custom profile hierarchies should derive from `Base`.
+- Breaking: renamed Parallelogram segment and constraint arguments by geometric role: `base`, `side`, and
+  `constraint` replace axis-implying constructor names.
+- Made degree-based sine and cosine exact at integer quarter turns, eliminating cardinal Geometry residue.
+- Documented complete file-system failure families for file comparison, output, touch, and upward location helpers.
+- Formalized generated Tile ids, positional CSS classes, template placement, and per-use callback signatures.
+- Formalized String and Symbol ids across Derender selection APIs and documented file-read failures consistently.
+- Breaking: made top-level `Decompile`, `Derender`, `Evaluate`, and `EvaluateChildren` consume inline SVG/XML;
+  file inputs now use the corresponding `File`-suffixed entrypoints.
+- Breaking: replaced callable drawing module `call` block registration with argument-independent `base` blocks;
+  inherited bases run parent-first, and modules with one drawing method conventionally name it `call`.
+- Breaking: made bracket and call notation the canonical Geometry constructors. Among Data value types, bracket notation
+  is public only for Point, Segment, LengthAngle, Margin, and Paper; use `.new` for Location and result carriers, and
+  `Stay` for traversal stop tokens.
+- Breaking: aligned Point and Segment comparison with Ruby `Comparable`; malformed or unrelated comparison operands now
+  return nil from `<=>`.
+- Breaking: executor entrypoints now return immutable `Executor::Result` values and expose only `execute` and
+  `execute_file`; inspect `result.error`, `result.stack`, and `result.value` instead of executor scopes or lifecycle state.
+- Breaking: wrapper attributes and callable arguments use distinct channels, `With` rejects parentless receivers, and
+  unsupported direct constructors are private; use the documented factories for Content, concrete Geometry lined
+  elements, and Grid query values.
+- Breaking: Canvas uses `.new` for explicit fields, `.from_paper(paper, **overrides)` for paper conversion, and
+  `.call`/`Graphics.canvas` for dispatch; the misleading keyword-only `.from_paper(width:, height:)` form was removed.
+- Breaking: `Save`, `Write`, `PNG`, `PDF`, and Sundries native export normalize successful destinations to expanded
+  String paths and create missing parent directories; change-aware SVG writes still return nil when unchanged.
+- Breaking: renamed `Derender.evaluate_file_children` to `evaluate_children_file`; decompiled nodes now own immutable
+  public state while parser, strategy, and construction plumbing remain private.
+- Expanded runtime/YARD parity checks and exact contracts for inherited, extended, generated, and dynamic API surfaces,
+  forwarded options, error channels, path ownership, whitespace, namespaces, nil behavior, and return values.
+
+### Fixed
+
+- Rejected directories from default file discovery while preserving custom locator matchers.
+- Kept `Ancestral` context in non-rendering `-context` metadata instead of leaking it into SVG attributes.
+- Preserved source Canvas units and names when deriving fitted Grid canvases.
+- Prevented stale documentation assets from mixing old layouts with new HTML, and moved sidebar navigation into the
+  tablet menu at 1024px and below.
+- Normalized numeric slots owned by path, shape, transform, tile, and Inkscape page helpers to finite SVG number spelling;
+  arbitrary user-supplied attributes remain untouched.
+- Made named callable wrapper and symbol ids stable while omitting defaults for anonymous modules, and indexed every
+  rendered id value, including false and numeric values, through its serialized string.
+- Preserved signed Geometry constraint directions, rejected invalid sweep/export channels through Sevgi error families,
+  and validated raw output paths before expansion or rendering.
+- Made callable module configuration copy-owned and freeze-aware, document subclasses inherit their nearest profile, and
+  false executor boot receivers remain explicit rather than defaulting to an internal scope.
+- Made element trees, attributes, identifiers, locator results, document profiles, Derender nodes, shell results, and
+  executor results retain owned immutable snapshots where their public contracts promise value semantics.
+- Corrected Shell combined-output separators, nil export density errors, document render-option routing, executor source
+  snapshots, selected-node namespace/whitespace documentation, and Standard character-data validation.
+
+### Removed
+
+- Removed public access to pluralization tables and the internal SVG save extension; pluralization rules are now deeply
+  immutable.
+- Removed public documentation and constant access for command-line implementation modules; the `sevgi` and `igves`
+  executables remain unchanged.
+- Removed eager loading and public documentation of private Showcase build/test support; explicit support entrypoints
+  now keep the harness under the Showcase namespace.
+- Removed public access to document profile name normalizers; registry operations retain them as private plumbing.
+- Removed the redundant `Margin.margin` constructor; use canonical bracket notation.
+- Removed public executor orchestration, obsolete callable-module hooks, the old public attribute syntax constants, and
+  direct construction of abstract or internally wired Content, Element, and Grid query types.
+- Removed accidental public access to abstract Lined factories, internal element-name/export maps, result/location
+  bracket constructors, and direct Stop construction.
+
 ## 0.95.0 - 2026-07-11
 
 ### Security

data/README.md

@@ -1,6 +1,6 @@
 # Sevgi
 
-Top-level API and `.sevgi` script runner.
+The `sevgi` gem provides the top-level API and the `.sevgi` script runner.
 
 ## Install
 
@@ -17,20 +17,38 @@ require "sevgi"
 ## Example
 
 ```ruby
-SVG(:minimal) do
-  rect(width: 3, height: 5)
+SVG :minimal do
+  rect width: 3, height: 5
 end.call
 ```
 
-## Executable
+## Executables
 
 ```sh
 sevgi drawing.sevgi
+igsev drawing.svg
 ```
 
+Both commands read standard input when the file is omitted or `-`. For `sevgi`, implicit `Save`, `PDF`, and `PNG`
+destinations use `output` as the input name; use `--as NAME` to choose another basename:
+
+```sh
+sevgi --as badge < drawing.sevgi
+igsev < drawing.svg > normalized.svg
+```
+
+`NAME` cannot include a directory. An explicit output path or `default:` argument in the script remains authoritative.
+With a file operand, `--as` keeps the file's source directory so relative `Load` calls continue to resolve there.
+
+`sevgi --skill` prints the validated path of the matching packaged agent skill. See the
+[Appendix documentation](https://github.com/roktas/sevgi/tree/main/appendix) for installation guidance.
+
+`igsev` converts an SVG file to Sevgi source, evaluates it with the complete DSL, and prints the resulting normalized
+SVG. Use `igves` from `sevgi-derender` when the generated Sevgi source itself is the desired output.
+
 ## Ruby compatibility
 
-Requires Ruby 3.4.0 or newer. CI verifies Ruby 3.4.0 and the current development Ruby from `.ruby-version`.
+Requires Ruby 3.4.0 or newer. CI verifies the current Ruby 3.4 release and the development Ruby from `.ruby-version`.
 
 ## Native prerequisites
 
@@ -55,7 +73,7 @@ gem install cairo rsvg2 hexapdf
 
 ## Links
 
-- Documentation: https://sevgi.roktas.dev
-- API documentation: https://www.rubydoc.info/gems/sevgi
-- Source: https://github.com/roktas/sevgi/tree/main/toplevel
-- Changelog: https://github.com/roktas/sevgi/blob/main/CHANGELOG.md
+- Documentation: <https://sevgi.roktas.dev>
+- API documentation: <https://www.rubydoc.info/gems/sevgi>
+- Source: <https://github.com/roktas/sevgi/tree/main/toplevel>
+- Changelog: <https://github.com/roktas/sevgi/blob/main/CHANGELOG.md>

data/bin/igsev

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "sevgi/binaries/igsev"
+
+Sevgi.const_get(:Binaries, false)::Igsev.(ARGV)

data/bin/sevgi

@@ -3,4 +3,4 @@
 
 require "sevgi/binaries/sevgi"
 
-Sevgi::Binaries::Sevgi.(ARGV)
+Sevgi.const_get(:Binaries, false)::Sevgi.(ARGV)

data/lib/sevgi/binaries/igsev.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "sevgi"
+
+module Sevgi
+  # Command-line entrypoint implementations shipped with Sevgi.
+  # @api private
+  module Binaries
+    # Implements the `igsev` executable that round-trips SVG files through Sevgi.
+    # @api private
+    module Igsev
+      extend self
+
+      # Executable name used in help output.
+      PROGNAME = "igsev"
+
+      # Error raised for invalid command-line usage.
+      Error = Class.new(::Sevgi::Error)
+
+      FLAGS = {
+        "--exception" => :vomit,
+        "--help" => :help,
+        "--version" => :version,
+        "-h" => :help,
+        "-v" => :version,
+        "-x" => :vomit
+      }.freeze
+      private_constant :FLAGS
+
+      # Parsed command-line options for the `igsev` executable.
+      # @api private
+      Options = Struct.new(:require, :vomit, :help, :version, :omit) do
+        # Parses command-line options and removes them from the argv array.
+        # @param argv [Array<String>] mutable command-line argument array
+        # @return [Sevgi::Binaries::Igsev::Options] parsed options
+        # @raise [Sevgi::Binaries::Igsev::Error] when an option is not recognized or a required value is missing
+        def self.parse(argv)
+          new.tap do |options|
+            until argv.empty? || argv.first == "-" || !argv.first.start_with?("-")
+              if argv.first == "--"
+                argv.shift
+                break
+              end
+
+              option(argv, options)
+            end
+          end
+        end
+
+        class << self
+          private
+
+          def option(argv, options)
+            arg = argv.shift
+            return options[FLAGS[arg]] = true if FLAGS.key?(arg)
+            if ["-r", "--require"].include?(arg)
+              return options.require = argv.shift || Error.("Option requires a library: #{arg}")
+            end
+
+            return (options.omit ||= []) << (argv.shift || Error.("No attribute given for --omit")) if arg == "--omit"
+
+            Error.("Not a valid option: #{arg}")
+          end
+        end
+      end
+
+      private_constant :Options
+
+      # Runs the `igsev` command-line interface.
+      # @param argv [Array<String>, String, nil] command-line arguments
+      # @return [nil]
+      # @raise [StandardError] when `--exception` or `SEVGI_VOMIT` requests raw errors
+      # @raise [SystemExit] when argv does not match `[options...] [--] [file|-]` or conversion aborts
+      def call(argv)
+        dispatch(Array(argv))
+      rescue Binaries::Igsev::Error => e
+        abort("#{e.message}\n\n#{help}")
+      end
+
+      private
+
+      def backtrace(error)
+        return error.load_backtrace if error.respond_to?(:load_backtrace)
+
+        error.backtrace || []
+      end
+
+      def die(error)
+        warn(error.message)
+        warn("")
+        backtrace(error).each { warn("  #{it}") }
+
+        exit(1)
+      end
+
+      def dispatch(argv)
+        options = Options.parse(argv)
+        return puts(help) if options.help
+        return puts(::Sevgi::VERSION) if options.version
+
+        emit(operand(argv), options)
+      rescue Binaries::Igsev::Error
+        raise
+      rescue ::StandardError => e
+        raise if raw_error?(options)
+
+        die(e)
+      end
+
+      def emit(file, options)
+        result = run(file, options)
+        unless result.success?
+          raise result.error if raw_error?(options)
+
+          die(result.error)
+        end
+
+        result.value.Out()
+      end
+
+      def help
+        <<~HELP
+          Usage: #{PROGNAME} [options...] [--] [SVG file|-]
+
+          See documentation for detailed help.
+
+          Options:
+
+              --omit ATTRIBUTE  Omit an attribute (repeatable)
+          -r, --require LIB     Require Ruby LIB while evaluating generated source
+          -x, --exception       Raise exception instead of abort
+              --                Stop option parsing
+
+          -h, --help            Show this help
+          -v, --version         Display version
+        HELP
+      end
+
+      def operand(argv)
+        file = argv.shift
+        Error.("Unexpected argument: #{argv.first}") unless argv.empty?
+
+        file unless file == "-"
+      end
+
+      def raw_error?(options) = options&.vomit || ENV.fetch(ENVVOMIT, nil)
+
+      def run(file, options)
+        source = if file
+          ::Sevgi::Derender.derender_file(file, omit: options.omit)
+        else
+          ::Sevgi::Derender.derender($stdin.read, omit: options.omit)
+        end
+
+        ::Sevgi.execute(source, require: options.require)
+      end
+    end
+  end
+
+  private_constant :Binaries
+end

data/lib/sevgi/binaries/rake.rb

@@ -14,11 +14,11 @@ module FileUtils
   # @param file [String] Sevgi script file, with or without `.sevgi` extension
   # @param args [Array] positional arguments exposed to the script as `ARGA`
   # @param kwargs [Hash] keyword arguments exposed to the script as `ARGH`
-  # @return [Sevgi::Executor::Scope, nil] execution scope, or nil for an empty file
+  # @return [Sevgi::Executor::Result] immutable execution result
   # @raise [Sevgi::ArgumentError] when the script file cannot be found
-  # @see Sevgi::Executor.execute_file
+  # @see Sevgi.execute_file
   def sevgi(file, *args, **kwargs)
-    Sevgi::Executor.execute_file(Sevgi::F.existing!(file, [Sevgi::EXTENSION])) do
+    Sevgi::Executor.__send__(:execute_file, Sevgi::F.existing!(file, [Sevgi::EXTENSION])) do
       extend(Sevgi)
 
       const_set(:ARGA, args).freeze

data/lib/sevgi/binaries/sevgi.rb

@@ -1,30 +1,53 @@
 # frozen_string_literal: true
 
 require "sevgi"
+require "sevgi/skill"
 
 module Sevgi
   # Command-line entrypoint implementations shipped with Sevgi.
+  # @api private
   module Binaries
     # Implements the `sevgi` executable.
+    # @api private
     module Sevgi
       extend self
 
       # Executable name used in help output.
       PROGNAME = "sevgi"
 
+      # Logical source name used for standard input.
+      STDIN_NAME = "output.sevgi"
+
       # Error raised for invalid command-line usage.
       Error = Class.new(::Sevgi::Error)
 
+      FLAGS = {
+        "-x" => :vomit,
+        "--exception" => :vomit,
+        "-h" => :help,
+        "--help" => :help,
+        "--skill" => :skill,
+        "-v" => :version,
+        "--version" => :version
+      }.freeze
+
       # Parsed command-line options for the `sevgi` executable.
       # @api private
-      Options = Struct.new(:require, :nomain, :vomit, :help, :version) do
+      Options = Struct.new(:require, :vomit, :help, :skill, :version, :as) do
         # Parses command-line options and removes them from the argv array.
         # @param argv [Array<String>] mutable command-line argument array
         # @return [Sevgi::Binaries::Sevgi::Options] parsed options
-        # @raise [Sevgi::Binaries::Sevgi::Error] when an option is not recognized
+        # @raise [Sevgi::Binaries::Sevgi::Error] when an option is not recognized or a required value is missing
         def self.parse(argv)
           new.tap do |options|
-            argv.first.start_with?("-") ? option(argv, options) : break until argv.empty?
+            until argv.empty? || argv.first == "-" || !argv.first.start_with?("-")
+              if argv.first == "--"
+                argv.shift
+                break
+              end
+
+              option(argv, options)
+            end
           end
         end
 
@@ -32,18 +55,14 @@ module Sevgi
           private
 
           def option(argv, options)
-            case (arg = argv.shift)
-            when "-r", "--require"
-              options.require = argv.shift
-            when "-n", "--nomain"
-              options.nomain = true
-            when "-x", "--exception"
-              options.vomit = true
-
-            when "-h", "--help"
-              options.help = true
-            when "-v", "--version"
-              options.version = true
+            arg = argv.shift
+            if (flag = FLAGS[arg])
+              options[flag] = true
+            elsif ["-r", "--require"].include?(arg)
+              options.require = argv.shift || Error.("Option requires a library: #{arg}")
+            elsif arg == "--as"
+              options.as = argv.shift
+              Error.("Option requires a name: --as") if options.as.nil? || options.as.empty?
             else
               Error.("Not a valid option: #{arg}")
             end
@@ -51,31 +70,31 @@ module Sevgi
         end
       end
 
-      private_constant :Options
+      private_constant :FLAGS, :Options, :STDIN_NAME
 
       # Runs the `sevgi` command-line interface.
       # @param argv [Array<String>, String, nil] command-line arguments
       # @return [nil]
       # @raise [Sevgi::Executor::Error] when `--exception` or `SEVGI_VOMIT` requests raw executor errors
-      # @raise [SystemExit] when command-line usage or script execution aborts
+      # @raise [SystemExit] when argv does not match `[options...] [--] [file|-]` or script execution aborts
       def call(argv)
         return puts(help) if (options = Options.parse(argv = Array(argv))).help
+        return puts(Skill.path) if options.skill
         return puts(::Sevgi::VERSION) if options.version
 
-        file = argv.shift
+        file = operand(argv)
         handle(run(file, options), file, options)
 
-      rescue Binaries::Sevgi::Error => e
+      rescue Skill::Error => e
         abort(e.message)
+      rescue Binaries::Sevgi::Error => e
+        abort("#{e.message}\n\n#{help}")
       end
 
       private
 
       def die(error, _file)
-        warn(error.message)
-        warn("")
-        error.backtrace!.each { warn("  #{it}") }
-
+        warn(error.message, "", *error.load_backtrace.map { "  #{it}" })
         exit(1)
       end
 
@@ -89,26 +108,49 @@ module Sevgi
 
       def help
         <<~HELP
-          Usage: #{PROGNAME} [options...] <Sevgi file>
+          Usage: #{PROGNAME} [options...] [--] [Sevgi file|-]
 
           See documentation for detailed help.
 
           Options:
 
-          -n, --nomain          Do not modify main object
+              --as NAME         Evaluate input as NAME for implicit output names
           -r, --require LIB     Require Ruby LIB
+              --skill           Display the packaged agent skill path
           -x, --exception       Raise exception instead of abort
+              --                Stop option parsing
 
           -h, --help            Show this help
           -v, --version         Display version
         HELP
       end
 
+      def operand(argv)
+        file = argv.shift
+        Error.("Unexpected argument: #{argv.first}") unless argv.empty?
+
+        file unless file == "-"
+      end
+
+      def execute_file(file, options)
+        name = source_name(options.as) if options.as
+        ::Sevgi.execute_file(file, as: name, require: options.require, main: true)
+      end
+
       def run(file, options)
-        Error.("No sevgi file given.") unless file
+        return execute_file(file, options) if file
 
-        ::Sevgi.execute_file(file, require: options.require, receiver: options.nomain ? nil : TOPLEVEL_BINDING.receiver)
+        ::Sevgi.execute($stdin.read, file: source_name(options.as), require: options.require, main: true)
+      end
+
+      def source_name(name)
+        return STDIN_NAME unless name
+
+        Error.("Option requires a name, not a path: --as") unless ::File.basename(name) == name
+        F.subext(".sevgi", name)
       end
     end
   end
+
+  private_constant :Binaries
 end

data/lib/sevgi/executor/error.rb

@@ -3,48 +3,40 @@
 module Sevgi
   class Executor
     # Raised when a source attempts to load another source already active in the same scope.
+    # @see https://sevgi.roktas.dev/execution/ Execution guide
     class CycleError < ::Sevgi::Error
     end
 
-    # Wraps an exception raised while executing Sevgi script source.
+    # Wraps an exception raised while executing Sevgi script source. Its visited source snapshot records every source in
+    # load order; it is not the active load stack at the instant of failure.
+    # @see https://sevgi.roktas.dev/execution/ Execution guide
     class Error < ::Sevgi::Error
-      # Returns the original script exception.
-      # @return [Exception]
-      attr_reader :error
-
-      # Returns the executor scope active when the error was captured.
-      # @return [Sevgi::Executor::Scope]
-      attr_reader :scope
-
       # Builds an executor error wrapper.
       # @param error [Exception] original exception
-      # @param scope [Sevgi::Executor::Scope] executor scope active at failure time
+      # @param stack [Array<String>] source file keys visited in load order; the Array and its String entries are copied
+      #   and frozen
       # @return [void]
-      def initialize(error, scope)
-        @error = error
-        @scope = scope
+      def initialize(error, stack)
+        @cause = error
+        @stack = stack.map { it.dup.freeze }.freeze
 
         super(error.message)
       end
 
-      # Returns backtrace entries that belong to the Sevgi load stack.
-      # @return [Array<String>] filtered backtrace lines relative to the current directory
-      def backtrace!
-        sources = stack.map { ::File.expand_path(it) }
+      # Returns backtrace entries that belong to the visited Sevgi source set.
+      # @return [Array<String>] filtered backtrace lines relative to the current directory, or an empty Array when the
+      #   original exception has no backtrace
+      def load_backtrace
+        sources = @stack.map { ::File.expand_path(it) }
 
-        error
-          .backtrace
+        Array(cause.backtrace)
           .select { sources.include?(::File.expand_path(it.split(":", 2).first)) }
           .map { |line| line.delete_prefix("#{::Dir.pwd}/") }
       end
 
       # Returns the original exception as the wrapped cause.
       # @return [Exception]
-      def cause = error
-
-      # Returns the script load stack active at failure time.
-      # @return [Array<String>] script file names in load order
-      def stack = scope.stack
+      attr_reader :cause
     end
   end
 end