feat: make policy length limits configurable per engine (#624)

- Add PolicyLengthConfig struct with max_col, max_file_bytes, and
  max_lines fields, replacing hardcoded constants in the lexer.
- Add Engine::set_policy_length_config and clear_policy_length_config
  to allow callers to override the default limits.
- Add Source::from_contents_with_limits and from_file_with_limits for
  direct Source construction with custom limits; existing from_contents
  and from_file signatures are preserved using defaults.
- Add tests for default rejection, custom limits, and engine plumbing.
- Add bindings for C, C++, Python, WASM/JS, Java, Ruby, C#, Go

bindings/csharp/Regorus/Engine.cs

@@ -82,6 +82,24 @@ namespace Regorus
                 CheckAndDropResult(Regorus.Internal.API.regorus_engine_clear_execution_timer_config((Regorus.Internal.RegorusEngine*)enginePtr));
             });
         }
+
+        public void SetPolicyLengthConfig(PolicyLengthConfig config)
+        {
+            var nativeConfig = config.ToNative();
+            UseHandle(enginePtr =>
+            {
+                CheckAndDropResult(Regorus.Internal.API.regorus_engine_set_policy_length_config((Regorus.Internal.RegorusEngine*)enginePtr, nativeConfig));
+            });
+        }
+
+        public void ClearPolicyLengthConfig()
+        {
+            UseHandle(enginePtr =>
+            {
+                CheckAndDropResult(Regorus.Internal.API.regorus_engine_clear_policy_length_config((Regorus.Internal.RegorusEngine*)enginePtr));
+            });
+        }
+
         public string? AddPolicy(string path, string rego)
         {
             return Utf8Marshaller.WithUtf8(path, pathPtr =>

bindings/csharp/Regorus/NativeMethods.cs

@@ -428,6 +428,18 @@ namespace Regorus.Internal
         [DllImport(LibraryName, EntryPoint = "regorus_engine_clear_execution_timer_config", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern RegorusResult regorus_engine_clear_execution_timer_config(RegorusEngine* engine);
 
+        /// <summary>
+        /// Set the policy length limits for a specific engine instance.
+        /// </summary>
+        [DllImport(LibraryName, EntryPoint = "regorus_engine_set_policy_length_config", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern RegorusResult regorus_engine_set_policy_length_config(RegorusEngine* engine, RegorusPolicyLengthConfig config);
+
+        /// <summary>
+        /// Clear the policy length configuration for a specific engine instance.
+        /// </summary>
+        [DllImport(LibraryName, EntryPoint = "regorus_engine_clear_policy_length_config", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern RegorusResult regorus_engine_clear_policy_length_config(RegorusEngine* engine);
+
         #endregion
 
         #region Execution Timer Global Methods
@@ -772,6 +784,17 @@ namespace Regorus.Internal
         public uint check_interval;
     }
 
+    /// <summary>
+    /// FFI representation of the policy length configuration.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct RegorusPolicyLengthConfig
+    {
+        public uint max_col;
+        public UIntPtr max_file_bytes;
+        public UIntPtr max_lines;
+    }
+
     /// <summary>
     /// Byte buffer returned from FFI.
     /// </summary>

bindings/csharp/Regorus/PolicyLengthConfig.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+
+namespace Regorus
+{
+    /// <summary>
+    /// Policy source length limits enforced when loading policy files.
+    /// </summary>
+    public readonly struct PolicyLengthConfig
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PolicyLengthConfig"/> struct.
+        /// </summary>
+        /// <param name="maxCol">Maximum column width per line. Must be non-zero.</param>
+        /// <param name="maxFileBytes">Maximum policy file size in bytes. Must be non-zero.</param>
+        /// <param name="maxLines">Maximum number of lines per policy file. Must be non-zero.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when any parameter is zero.</exception>
+        public PolicyLengthConfig(uint maxCol, nuint maxFileBytes, nuint maxLines)
+        {
+            if (maxCol == 0)
+                throw new ArgumentOutOfRangeException(nameof(maxCol), "Must be non-zero.");
+            if (maxFileBytes == 0)
+                throw new ArgumentOutOfRangeException(nameof(maxFileBytes), "Must be non-zero.");
+            if (maxLines == 0)
+                throw new ArgumentOutOfRangeException(nameof(maxLines), "Must be non-zero.");
+
+            MaxCol = maxCol;
+            MaxFileBytes = maxFileBytes;
+            MaxLines = maxLines;
+        }
+
+        /// <summary>Maximum column width per line (default: 1024).</summary>
+        public uint MaxCol { get; }
+
+        /// <summary>Maximum policy file size in bytes (default: 1 MiB).</summary>
+        public nuint MaxFileBytes { get; }
+
+        /// <summary>Maximum number of lines per policy file (default: 20000).</summary>
+        public nuint MaxLines { get; }
+
+        internal Regorus.Internal.RegorusPolicyLengthConfig ToNative()
+        {
+            return new Regorus.Internal.RegorusPolicyLengthConfig
+            {
+                max_col = MaxCol,
+                max_file_bytes = MaxFileBytes,
+                max_lines = MaxLines,
+            };
+        }
+    }
+}

bindings/csharp/TestApp/Program.cs

@@ -20,6 +20,8 @@ w.Restart();
 
 var engine = new Regorus.Engine();
 engine.SetRegoV0(true);
+// Raise the default col limit to 2000
+engine.SetPolicyLengthConfig(new Regorus.PolicyLengthConfig(maxCol: 2000, maxFileBytes: 1048576, maxLines: 20000));
 
 w.Stop();
 var newEngineTicks = w.ElapsedTicks;