tina4ruby 3.13.137 → 3.13.138

data/lib/tina4/shutdown.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 module Tina4
   # Graceful shutdown on SIGTERM / SIGINT.
@@ -80,10 +86,9 @@ module Tina4
         @shutdown_complete = true
         return if drained
 
-        # The deadline expired with requests still in flight. WEBrick's accept
-        # loop joins its worker threads with NO timeout of its own, so simply
-        # returning here would hang the process for as long as the slowest
-        # handler runs - exactly what TINA4_SHUTDOWN_TIMEOUT exists to prevent.
+        # The deadline expired with requests still in flight. Returning here
+        # would let the process live for as long as the slowest handler runs -
+        # exactly what TINA4_SHUTDOWN_TIMEOUT exists to prevent.
         # Flush first: exit! runs no at_exit handlers and does not flush stdio,
         # which would swallow the warning that explains the forced exit.
         $stdout.flush
@@ -107,10 +112,9 @@ module Tina4
 
       # Block until initiate_shutdown has finished every teardown step.
       #
-      # stop_accepting unblocks WEBrick's accept loop immediately, so its #start
-      # returns as soon as the in-flight workers are joined - which can be while
-      # the signal handler's thread is still stopping background tasks and
-      # closing database connections. The server's main thread calls this so the
+      # stop_accepting unblocks the built-in server's accept loop immediately, so
+      # its #start returns while the signal handler's thread is still draining
+      # requests, stopping background tasks and closing database connections. The server's main thread calls this so the
       # process does not exit out from under that teardown.
       def wait_for_completion(timeout = nil)
         return unless @shutting_down
@@ -144,13 +148,12 @@ module Tina4
         DEFAULT_TIMEOUT
       end
 
-      # Close the listening socket BEFORE draining. WEBrick's #shutdown wakes its
-      # accept loop and closes the listeners; it does not touch the worker
-      # threads already running, which the loop's own ensure joins - so new
+      # Close the listening socket BEFORE draining. Tina4::HttpServer#shutdown
+      # closes every listener and every keep-alive connection that is waiting
+      # for its next request; it does not touch a request being served - so new
       # connections are refused while in-flight requests still run to completion
-      # and write their full response. Measured on webrick 1.9.2 / Ruby 4.0.2:
-      # #shutdown returns in ~0.1ms, a connection attempted 0.3s later is
-      # ECONNREFUSED, and the 2s handler mid-flight still returns a full 200.
+      # and write their full response (spec/graceful_shutdown_spec.rb proves all
+      # three on a real SIGTERM).
       def stop_accepting
         return unless @server.respond_to?(:shutdown)
 

data/lib/tina4/smtp_client.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+
+require "socket"
+require_relative "mail_socket"
+require_relative "base64"
+
+module Tina4
+  class Messenger
+    # Tina4's own SMTP client (RFC 5321), replacing the net-smtp gem. It covers
+    # exactly what Messenger sends with:
+    #
+    #   * transport: plain, STARTTLS, or implicit TLS. Implicit TLS defaults to
+    #     port 465, the rule Python (SMTP_SSL), PHP (ssl://) and Node (tls.connect)
+    #     already follow; the caller may also ask for it on any port (tls: true).
+    #     STARTTLS is REQUIRED when asked for: a server that does not offer it
+    #     fails the send rather than silently getting the message and the
+    #     credentials in clear (Net::SMTP#enable_starttls did the same).
+    #   * AUTH PLAIN, or AUTH LOGIN when that is all the server offers.
+    #   * MAIL FROM / RCPT TO / DATA with CRLF normalisation and dot-stuffing.
+    #
+    #   SmtpClient.start(host: "smtp.example.com", port: 587, starttls: true,
+    #                    username: "u", password: "p") do |smtp|
+    #     smtp.send_message(raw_message, "from@example.com", ["to@example.com"])
+    #   end
+    class SmtpClient
+      # A server reply outside the expected codes; the message is the reply text.
+      class Error < StandardError
+        attr_reader :code
+
+        def initialize(code, message)
+          @code = code
+          super(message)
+        end
+      end
+
+      IMPLICIT_TLS_PORT = 465
+
+      def self.start(**options)
+        client = new(**options)
+        client.connect
+        return client unless block_given?
+
+        begin
+          yield client
+        ensure
+          client.quit
+        end
+      end
+
+      # auth_mechanism forces "PLAIN" or "LOGIN"; nil picks from the server's
+      # EHLO list (PLAIN preferred, as Net::SMTP's :plain always sent).
+      def initialize(host:, port:, tls: nil, starttls: false, username: nil, password: nil,
+                     auth_mechanism: nil, timeout: 30, helo_domain: nil)
+        @host = host
+        @port = port.to_i
+        @implicit_tls = tls.nil? ? @port == IMPLICIT_TLS_PORT : tls
+        @starttls = starttls
+        @username = username
+        @password = password
+        @auth_mechanism = auth_mechanism&.upcase
+        @timeout = timeout
+        @helo_domain = helo_domain || local_host_name
+        @capabilities = []
+        @socket = nil
+      end
+
+      attr_reader :capabilities
+
+      def implicit_tls?
+        @implicit_tls
+      end
+
+      def tls?
+        @socket&.tls? || false
+      end
+
+      def connect
+        @socket = MailSocket.open(@host, @port, tls: implicit_tls?, timeout: @timeout)
+        read_reply(220)
+        greet
+        upgrade_to_tls if @starttls && !implicit_tls?
+        authenticate if @username && @password
+        self
+      rescue StandardError
+        close
+        raise
+      end
+
+      def send_message(message, from, recipients)
+        recipients = Array(recipients).map { |recipient| envelope_address(recipient) }
+        raise ArgumentError, "at least one recipient is required" if recipients.empty?
+
+        command("MAIL FROM:<#{envelope_address(from)}>", 250)
+        recipients.each { |recipient| command("RCPT TO:<#{recipient}>", 250, 251) }
+        command("DATA", 354)
+        @socket.write(self.class.data_block(message))
+        read_reply(250)
+      end
+
+      # QUIT politely, then close. Never raises: the message is already queued.
+      def quit
+        return unless @socket
+
+        begin
+          command("QUIT", 221)
+        rescue StandardError
+          nil
+        end
+        close
+      end
+
+      def close
+        @socket&.close
+        @socket = nil
+      end
+
+      # The DATA payload: every line ending normalised to CRLF, a line starting
+      # with "." doubled (RFC 5321 4.5.2), terminated by CRLF.CRLF.
+      def self.data_block(message)
+        data = message.to_s.b.gsub(/\r\n|\r|\n/n, "\r\n")
+        data << "\r\n" unless data.end_with?("\r\n")
+        data.gsub(/^\./n, "..") + ".\r\n"
+      end
+
+      private
+
+      def greet
+        @capabilities = command("EHLO #{@helo_domain}", 250).drop(1)
+      rescue Error => e
+        raise unless (500..599).cover?(e.code)
+
+        # A server that does not speak ESMTP: plain HELO, no extensions.
+        command("HELO #{@helo_domain}", 250)
+        @capabilities = []
+      end
+
+      def upgrade_to_tls
+        unless capability?("STARTTLS")
+          raise Error.new(0, "STARTTLS was requested but #{@host}:#{@port} does not offer it")
+        end
+
+        command("STARTTLS", 220)
+        @socket.start_tls
+        greet # capabilities change once the channel is encrypted (AUTH often appears)
+      end
+
+      def authenticate
+        case auth_mechanism
+        when "PLAIN"
+          command("AUTH PLAIN #{Tina4::Base64.strict_encode64("\0#{@username}\0#{@password}")}", 235)
+        when "LOGIN"
+          command("AUTH LOGIN", 334)
+          command(Tina4::Base64.strict_encode64(@username.to_s), 334)
+          command(Tina4::Base64.strict_encode64(@password.to_s), 235)
+        end
+      end
+
+      def auth_mechanism
+        return @auth_mechanism if @auth_mechanism
+
+        offered = @capabilities.filter_map { |line| line[/\AAUTH[ =](.*)\z/i, 1] }
+                               .flat_map { |list| list.upcase.split }
+        return "PLAIN" if offered.empty? || offered.include?("PLAIN")
+        return "LOGIN" if offered.include?("LOGIN")
+
+        raise Error.new(0, "#{@host}:#{@port} offers no supported AUTH mechanism (offered: #{offered.join(' ')})")
+      end
+
+      def capability?(name)
+        @capabilities.any? { |line| line.split(/[ =]/, 2).first.casecmp?(name) }
+      end
+
+      # Send one command line and read its reply; returns the reply lines.
+      def command(line, *expected)
+        if line.match?(/[\r\n]/)
+          raise ArgumentError, "SMTP command contains a line break"
+        end
+
+        @socket.write("#{line}\r\n")
+        read_reply(*expected)
+      end
+
+      # A reply is one or more "NNN-text" lines ending with "NNN text".
+      def read_reply(*expected)
+        lines = []
+        code = nil
+        loop do
+          raw = @socket.read_line.force_encoding(Encoding::UTF_8).scrub.chomp
+          code = raw[0, 3].to_i
+          lines << raw[4..].to_s
+          break unless raw[3] == "-"
+        end
+        return lines if expected.empty? || expected.include?(code)
+
+        raise Error.new(code, "#{code} #{lines.join(' ')}".strip)
+      end
+
+      # The bare address for the envelope: "Name <a@b>" -> "a@b". CR, LF and
+      # angle brackets inside it would let a caller inject SMTP commands.
+      def envelope_address(address)
+        text = address.to_s.strip
+        text = Regexp.last_match(1).strip if text =~ /<([^<>]*)>\s*\z/
+        raise ArgumentError, "invalid email address #{address.inspect}" if text.match?(/[\r\n<>]/)
+
+        text
+      end
+
+      def local_host_name
+        name = Socket.gethostname.to_s
+        name.match?(/\A[A-Za-z0-9.\-]+\z/) ? name : "localhost"
+      rescue StandardError
+        "localhost"
+      end
+    end
+  end
+end

data/lib/tina4/sql_translator.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "digest"
 require_relative "cache"
@@ -150,11 +156,98 @@ module Tina4
         [out, literals]
       end
 
+      # Rewrite every PLACEHOLDER `?` in +sql+ with the block's answer for its
+      # zero-based index, leaving every `?` that is not a placeholder alone
+      # (tina4-python #138). Skipped: string literals ('...' with '' escapes,
+      # Postgres E'...' with backslash escapes, $$...$$ and $tag$...$tag$),
+      # quoted identifiers ("..." and `...`, plus [...] when +brackets+ is true
+      # for SQL Server - never elsewhere, where arr[?] is a real placeholder)
+      # and comments (-- and /* */). A `%` is never special here.
+      #
+      # The two Ruby drivers that rewrite `?` both did a plain text rewrite:
+      # Postgres (? -> $n) turned SELECT 'why?', ? into 'why$1', $2; MSSQL
+      # (? -> escaped value, one sub at a time) also rewrote a `?` inside a
+      # value it had just spliced in.
+      def replace_placeholders(sql, brackets: false)
+        out = +""
+        index = 0
+        i = 0
+        n = sql.length
+        while i < n
+          span_end = placeholder_skip_span(sql, i, brackets)
+          if span_end
+            out << sql[i...span_end]
+            i = span_end
+          elsif sql[i] == "?"
+            out << yield(index).to_s
+            index += 1
+            i += 1
+          else
+            out << sql[i]
+            i += 1
+          end
+        end
+        out
+      end
+
       # Inverse of #mask_literals.
       def restore_literals(masked, literals)
         masked.gsub(/\x00(\d+)\x00/) { literals[::Regexp.last_match(1).to_i] }
       end
 
+      # When a literal, quoted identifier or comment STARTS at +i+, the index
+      # just past its end; otherwise nil. An unterminated span runs to the end.
+      def placeholder_skip_span(sql, i, brackets)
+        ch = sql[i]
+        nxt = sql[i + 1]
+        return sql.index("\n", i) || sql.length if ch == "-" && nxt == "-"
+        return (sql.index("*/", i + 2)&.+(2)) || sql.length if ch == "/" && nxt == "*"
+        return quoted_span_end(sql, i, "'", backslash: e_string?(sql, i)) if ch == "'"
+        return quoted_span_end(sql, i, ch) if ch == '"' || ch == "`"
+        return quoted_span_end(sql, i, "]") if brackets && ch == "["
+        return dollar_span_end(sql, i) if ch == "$"
+
+        nil
+      end
+
+      # The end of a span opened at +i+ and closed by +close+, where a doubled
+      # closer is an escaped one ('' "" `` ]]) and, for an E'...' string, a
+      # backslash escapes the next character.
+      def quoted_span_end(sql, i, close, backslash: false)
+        j = i + 1
+        n = sql.length
+        while j < n
+          if backslash && sql[j] == "\\"
+            j += 2
+          elsif sql[j] == close
+            return j + 1 unless sql[j + 1] == close
+
+            j += 2
+          else
+            j += 1
+          end
+        end
+        n
+      end
+
+      # A Postgres escape string: E'...' / e'...' where the E is its own token.
+      def e_string?(sql, i)
+        i.positive? && sql[i - 1].match?(/[eE]/) && (i < 2 || !sql[i - 2].match?(/[A-Za-z0-9_$]/))
+      end
+
+      # A Postgres dollar-quoted string ($$...$$ or $tag$...$tag$) starting at
+      # +i+, or nil. `$1` is a numbered parameter, not a tag (tags cannot start
+      # with a digit), and a `$` inside an identifier (a$b) opens nothing.
+      def dollar_span_end(sql, i)
+        return nil if i.positive? && sql[i - 1].match?(/[A-Za-z0-9_]/)
+
+        tag = sql[i..][/\A\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/]
+        return nil unless tag
+
+        close = sql.index(tag, i + tag.length)
+        close ? close + tag.length : sql.length
+      end
+
       # Convert || string concatenation to CONCAT() for MySQL/MSSQL. Rewrites ONLY
       # || operators joining expression operands OUTSIDE any string literal or
       # comment, and only the operand chain - never the whole statement.

data/lib/tina4/sqlite3_gem.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+
+module Tina4
+  # The sqlite3 gem is an APPLICATION dependency, not a framework one
+  # (ADR-0067): `tina4 init ruby` writes gem "sqlite3" into the project's
+  # Gemfile, and tina4ruby itself never declares it, exactly like pg, mysql2 and
+  # the other drivers. Everything that opens SQLite goes through here so a
+  # project without the gem gets one actionable message instead of a bare
+  # "cannot load such file -- sqlite3".
+  SQLITE3_MISSING_MESSAGE =
+    "The 'sqlite3' gem is required for SQLite connections. Add gem \"sqlite3\" " \
+    "to your Gemfile (tina4 init ruby does this for you), or install one of:\n" \
+    "    bundle add sqlite3     # if your project uses Bundler\n" \
+    "    gem install sqlite3    # bare driver"
+
+  def self.require_sqlite3!
+    require "sqlite3"
+  rescue LoadError
+    raise LoadError, SQLITE3_MISSING_MESSAGE
+  end
+end

data/lib/tina4/sso.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-require "base64"
+
+require_relative "base64"
 require "digest"
 require "json"
 require "net/http"
 require "openssl"
 require "securerandom"
 require "uri"
+require_relative "parse_json"
 
 module Tina4
   class SsoError < StandardError; end
@@ -42,7 +49,7 @@ module Tina4
 
     def json_env(name, fallback)
       raw = ENV[name]
-      raw.nil? || raw.empty? ? fallback : JSON.parse(raw)
+      raw.nil? || raw.empty? ? fallback : Tina4.parse_json(raw)
     rescue JSON::ParserError => e
       raise SsoError, "#{name} must be valid JSON", cause: e
     end
@@ -83,7 +90,7 @@ module Tina4
       http.read_timeout = 10
       response = http.request(request)
       raise SsoError, "OIDC provider request failed" unless response.is_a?(Net::HTTPSuccess)
-      result = JSON.parse(response.body)
+      result = Tina4.parse_json(response.body)
       raise SsoError, "OIDC provider returned a non-object response" unless result.is_a?(Hash)
       result
     rescue JSON::ParserError, IOError, SystemCallError, Timeout::Error => e
@@ -119,7 +126,7 @@ module Tina4
       state = SecureRandom.urlsafe_base64(32)
       nonce = SecureRandom.urlsafe_base64(32)
       verifier = SecureRandom.urlsafe_base64(64)
-      challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
+      challenge = Tina4::Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
       current.set(PENDING_KEY, {
                     "state" => state, "nonce" => nonce, "verifier" => verifier,
                     "return_to" => self.class.safe_return(return_to), "created_at" => Time.now.to_i
@@ -140,7 +147,7 @@ module Tina4
 
     def self.jwt_payload(token)
       part = token.split(".")[1].to_s
-      JSON.parse(Base64.urlsafe_decode64(part.ljust((part.length + 3) / 4 * 4, "=")))
+      Tina4.parse_json(Tina4::Base64.urlsafe_decode64(part.ljust((part.length + 3) / 4 * 4, "=")))
     rescue JSON::ParserError, ArgumentError
       raise SsoError, "provider returned an invalid ID token"
     end
@@ -178,9 +185,19 @@ module Tina4
       }
     end
 
+    # The provider's code and state arrive in the QUERY STRING. They used to be
+    # read from request.params, which carries ROUTE path params only
+    # (REQ-PARAM-POLLUTION), so the built-in /auth/callback never saw them and
+    # could not complete a sign-in. Parity with the Python master (sso.py reads
+    # request.query). A bare Session has no query - pass +query+ explicitly.
+    def self.query_of(request_or_session)
+      query = request_or_session.respond_to?(:query) ? request_or_session.query : nil
+      query.is_a?(Hash) ? query : {}
+    end
+
     def callback(request_or_session, query = nil)
       current = session(request_or_session)
-      values = query || request_or_session.params
+      values = query || self.class.query_of(request_or_session)
       pending = current&.get(PENDING_KEY)
       current&.delete(PENDING_KEY)
       unless pending.is_a?(Hash) && !values["code"].to_s.empty? && self.class.secure_equal(values["state"], pending["state"])
@@ -263,7 +280,7 @@ module Tina4
       end
       sso = from_issuer
       Tina4::Router.get("/auth/login") do |request, response|
-        response.redirect(sso.login(request, request.params["return_to"] || "/"))
+        response.redirect(sso.login(request, query_of(request)["return_to"] || "/"))
       end
       Tina4::Router.get("/auth/callback") do |request, response|
         begin
@@ -273,7 +290,7 @@ module Tina4
         end
       end
       Tina4::Router.post("/auth/logout") do |request, response|
-        response.redirect(sso.logout(request, request.params["return_to"] || "/"))
+        response.redirect(sso.logout(request, query_of(request)["return_to"] || "/"))
       end
       @mounted = true
       true

data/lib/tina4/swagger.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 
 module Tina4

data/lib/tina4/template.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 module Tina4
   module Template

data/lib/tina4/test.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 # Tina4 — The Intelligent Native Application 4ramework
-# Copyright 2007 - current Tina4
-# License: MIT https://opensource.org/licenses/MIT
+# Copyright (c) 2026 Code Infinity
+# License: MPL-2.0 https://mozilla.org/MPL/2.0/
 
 module Tina4
   # Tina4 xUnit-style test base class — class-based test suites with HTTP

data/lib/tina4/test_client.rb

@@ -1,3 +1,9 @@
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 # Tina4 Test Client — Test routes without starting a server.
 #
 # Usage:
@@ -14,6 +20,7 @@
 #   response = client.get("/api/users/1", headers: { "Authorization" => "Bearer token123" })
 #
 require "stringio" # rack.input is a StringIO; require it here so a clean `require "tina4"` boot never NameErrors
+require_relative "parse_json"
 
 module Tina4
   class TestResponse
@@ -64,7 +71,7 @@ module Tina4
     # Parse body as JSON.
     def json
       return nil if @body.nil? || @body.empty?
-      JSON.parse(@body)
+      Tina4.parse_json(@body)
     rescue JSON::ParserError
       nil
     end

data/lib/tina4/testing.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require "stringio"
+require_relative "parse_json"
 
 module Tina4
   module Testing
@@ -281,7 +288,7 @@ module Tina4
       end
 
       def assert_json(response_body)
-        JSON.parse(response_body)
+        Tina4.parse_json(response_body)
       rescue JSON::ParserError => e
         raise TestFailure, "Invalid JSON: #{e.message}"
       end

data/lib/tina4/validator.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "json"
 

data/lib/tina4/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 module Tina4
-  VERSION = "3.13.137"
+  VERSION = "3.13.138"
 end