parse-stack-next 5.5.6 → 5.7.0

data/lib/parse/vector_search.rb

@@ -95,6 +95,44 @@ module Parse
     # one. Atlas's guidance: numCandidates ≥ 10 × limit, ≤ 10_000.
     DEFAULT_NUM_CANDIDATES_MULTIPLIER = 20
 
+    # How far past `k` the `$vectorSearch.limit` is raised when
+    # something downstream can drop rows (ACL enforcement, a
+    # caller-supplied `filter`, `protectedFields`, or pointer-field
+    # filtering). Atlas applies `limit` BEFORE any of those run, so
+    # without overfetching a caller who can read 2 of the top 10 asks
+    # for 10 and receives 2 — even when hundreds of readable matches
+    # exist further down the ranking.
+    #
+    # This is a mitigation, not a guarantee: a sufficiently selective
+    # ACL can still exhaust any finite candidate window. Deterministic
+    # fill would require `_rperm` declared as `type: "filter"` in the
+    # Atlas index (so the prefilter enforces visibility) or iterative
+    # candidate expansion. The instrumentation emitted by {.search}
+    # exists so an underfill is observable rather than silent.
+    DEFAULT_CANDIDATE_MULTIPLIER = 10
+
+    # Ceiling on the internally-raised candidate window. Atlas caps
+    # `numCandidates` at 10_000 and `numCandidates` must be >= `limit`,
+    # so the candidate window cannot usefully exceed that.
+    MAX_CANDIDATE_LIMIT = 10_000
+
+    # Emitted once per {.search}. The counts are deliberately named for
+    # where they are actually measured — there is no cheap way to learn
+    # how many rows `$vectorSearch` emitted before the server-side
+    # `$match` stages ran, so no field claims to be that number:
+    #
+    # * `candidate_limit` / `num_candidates` — the requested window.
+    # * `post_filter_count` — rows returned by the pipeline, i.e. after
+    #   the server-side ACL `$match` and any caller `filter`.
+    # * `post_pointer_count` — rows left after client-side redaction and
+    #   pointer-field filtering.
+    # * `returned_count` — rows handed back, after trimming to `k`.
+    # * `underfilled` — the caller received fewer than `k`.
+    #
+    # Obtaining a true pre-`$match` count would require a `$facet`, at
+    # the cost of a second pass over the candidate set.
+    AS_NOTIFICATION_NAME = "parse.vector_search.search"
+
     # Accepted {.index_drift_policy} values.
     INDEX_DRIFT_POLICIES = %i[warn raise ignore].freeze
 
@@ -130,6 +168,7 @@ module Parse
       def index_drift_policy
         @index_drift_policy ||= :warn
       end
+
       # Low-level `$vectorSearch` entry point.
       #
       # @param collection_name [String] Parse class name / Mongo
@@ -165,8 +204,9 @@ module Parse
       #   `_vscore` rather than `_score` so hybrid pipelines with
       #   Atlas Search don't collide on the same key).
       def search(collection_name, field:, query_vector:, k: 10,
-                 num_candidates: nil, filter: nil, vector_filter: nil,
-                 index: nil, max_time_ms: nil, **scope_opts)
+                                  num_candidates: nil, candidate_limit: nil, filter: nil,
+                                  vector_filter: nil, index: nil, max_time_ms: nil, **scope_opts)
+        candidate_limit_override = candidate_limit
         require_available!
         index_name = (index || @default_index)
         if index_name.nil? || index_name.to_s.empty?
@@ -195,12 +235,61 @@ module Parse
           raise ArgumentError, "k must be in 1..#{MAX_K} (got #{k_int})."
         end
 
-        num_candidates_int = (num_candidates || (k_int * DEFAULT_NUM_CANDIDATES_MULTIPLIER)).to_i
+        # Anything that can drop rows AFTER Atlas has already applied
+        # `limit` forces an overfetch, otherwise the caller silently
+        # receives fewer than `k`. Master mode with no caller filter
+        # has no attrition, so it keeps the old one-for-one cost.
+        attrition_possible = !resolution.master? || !(filter.nil? || filter.empty?)
+        candidate_limit = if candidate_limit_override
+            Integer(candidate_limit_override)
+          elsif attrition_possible
+            [k_int * DEFAULT_CANDIDATE_MULTIPLIER, MAX_CANDIDATE_LIMIT].min
+          else
+            k_int
+          end
+        if candidate_limit < k_int
+          raise ArgumentError,
+                "candidate_limit (#{candidate_limit}) must be >= k (#{k_int})."
+        end
+        if candidate_limit > MAX_CANDIDATE_LIMIT
+          raise ArgumentError,
+                "candidate_limit capped at #{MAX_CANDIDATE_LIMIT} by Atlas (got #{candidate_limit})."
+        end
+
+        # ANN width stays anchored to `k`, NOT to the raised window.
+        # Deriving it from `candidate_limit` would multiply twice and
+        # silently widen the HNSW search by the candidate multiplier —
+        # a scoped k=10 would jump from 200 to 2000 candidates. The
+        # window only needs numCandidates to be at least as large as
+        # `limit`, so take whichever is greater.
+        derived_num_candidates =
+          [k_int * DEFAULT_NUM_CANDIDATES_MULTIPLIER, candidate_limit].max
+        num_candidates_int = (num_candidates || derived_num_candidates).to_i
+        num_candidates_int = MAX_CANDIDATE_LIMIT if num_candidates_int > MAX_CANDIDATE_LIMIT &&
+                                                    num_candidates.nil?
+
+        # A caller-supplied num_candidates that predates the candidate
+        # window used to be valid whenever it was >= k. Clamping the
+        # implicit window down to it keeps those calls working rather
+        # than turning them into a new ArgumentError. An EXPLICIT
+        # candidate_limit still conflicts loudly — that combination can
+        # only be a mistake.
+        if num_candidates && num_candidates_int < candidate_limit
+          if candidate_limit_override
+            raise ArgumentError,
+                  "num_candidates (#{num_candidates_int}) must be >= candidate_limit " \
+                  "(#{candidate_limit})."
+          end
+          candidate_limit = [num_candidates_int, k_int].max
+        end
+
         if num_candidates_int < k_int
-          raise ArgumentError, "num_candidates (#{num_candidates_int}) must be >= k (#{k_int})."
+          raise ArgumentError,
+                "num_candidates (#{num_candidates_int}) must be >= k (#{k_int})."
         end
-        if num_candidates_int > 10_000
-          raise ArgumentError, "num_candidates capped at 10000 by Atlas (got #{num_candidates_int})."
+        if num_candidates_int > MAX_CANDIDATE_LIMIT
+          raise ArgumentError,
+                "num_candidates capped at #{MAX_CANDIDATE_LIMIT} by Atlas (got #{num_candidates_int})."
         end
 
         validated_vector = validate_query_vector!(query_vector)
@@ -219,11 +308,13 @@ module Parse
         )
 
         vs_stage = {
-          "index"         => index_name.to_s,
-          "path"          => path,
-          "queryVector"   => validated_vector,
+          "index" => index_name.to_s,
+          "path" => path,
+          "queryVector" => validated_vector,
           "numCandidates" => num_candidates_int,
-          "limit"         => k_int,
+          # Deliberately the raised candidate window, not `k` — the
+          # result set is trimmed to `k` after enforcement runs.
+          "limit" => candidate_limit,
         }
         vs_stage["filter"] = vector_filter if vector_filter && !vector_filter.empty?
         pipeline = [{ "$vectorSearch" => vs_stage }]
@@ -247,7 +338,11 @@ module Parse
 
         pipeline << { "$match" => filter } if filter
 
-        raw_results = run_pipeline!(collection_name, pipeline, max_time_ms: max_time_ms)
+        raw_results = run_pipeline!(collection_name, pipeline, max_time_ms: max_time_ms,
+                                                               authorizing_client: Parse::ACLScope.client_of(resolution))
+        # Already past the server-side ACL `$match` and any caller
+        # `filter` — NOT the number $vectorSearch emitted.
+        post_filter_count = raw_results.length
 
         # Post-fetch enforcement: walk the rows the same way
         # Parse::MongoDB.aggregate would. Master mode skips every
@@ -266,9 +361,40 @@ module Parse
         # every mode, master included, so `_hashed_password` /
         # `_session_token` can never surface through this entry point.
         raw_results.map! { |doc| Parse::PipelineSecurity.strip_internal_fields(doc) }
+
+        # Trim only AFTER every enforcement layer has run — that
+        # ordering is the whole point of the raised candidate window.
+        post_pointer_count = raw_results.length
+        raw_results = raw_results.first(k_int) if post_pointer_count > k_int
+
+        emit_search_stats(
+          collection_name: collection_name, k: k_int,
+          candidate_limit: candidate_limit, num_candidates: num_candidates_int,
+          post_filter_count: post_filter_count, post_pointer_count: post_pointer_count,
+          returned_count: raw_results.length, master: resolution.master?,
+        )
+
         raw_results
       end
 
+      # @!visibility private
+      # Emit per-search counts so ACL/filter attrition is observable.
+      # `underfilled` means the caller received fewer rows than they
+      # asked for — the signal worth alerting on, since it means either
+      # the candidate window was too small for this principal or the
+      # collection simply ran out of matches. Distinguishing those two
+      # would need a pre-`$match` count, which this deliberately does
+      # not fabricate.
+      def emit_search_stats(**payload)
+        return unless defined?(ActiveSupport::Notifications)
+
+        payload[:pointer_attrition] =
+          payload[:post_filter_count] - payload[:post_pointer_count]
+        payload[:underfilled] = payload[:returned_count] < payload[:k]
+        ActiveSupport::Notifications.instrument(AS_NOTIFICATION_NAME, payload)
+        nil
+      end
+
       # Validate a query vector. Public so callers (and tests) can
       # invoke it independently of {.search}.
       #
@@ -359,10 +485,12 @@ module Parse
       # `Parse::MongoDB.aggregate` because that helper prepends an
       # ACL `$match` at stage 0, which Atlas rejects for any pipeline
       # whose stage 0 is `$vectorSearch`.
-      def run_pipeline!(collection_name, pipeline, max_time_ms: nil)
+      def run_pipeline!(collection_name, pipeline, max_time_ms: nil, authorizing_client: nil)
         agg_opts = {}
         agg_opts[:max_time_ms] = max_time_ms if max_time_ms
-        coll = Parse::MongoDB.collection(collection_name)
+        # Vector search bypasses Parse::MongoDB.aggregate, so the binding
+        # guard only sees this read if the authorizing client arrives here.
+        coll = Parse::MongoDB.collection(collection_name, authorizing_client: authorizing_client)
         coll.aggregate(pipeline, agg_opts).to_a
       rescue => e
         Parse::MongoDB.send(:raise_if_timeout!, e, collection_name, max_time_ms)

data/lib/parse/webhooks/payload.rb

@@ -718,6 +718,7 @@ module Parse
         @deferred_callbacks << block
         true
       end
+
       alias_method :defer, :after_response
 
       # @!visibility private

data/lib/parse/webhooks/registration.rb

@@ -33,10 +33,10 @@ module Parse
       def assert_webhook_url_safe!(url)
         raise ArgumentError, "Webhook URL is required" if url.nil? || url.to_s.empty?
         uri = begin
-          URI.parse(url.to_s)
-        rescue URI::InvalidURIError => e
-          raise ArgumentError, "Invalid webhook URL: #{e.message}"
-        end
+            URI.parse(url.to_s)
+          rescue URI::InvalidURIError => e
+            raise ArgumentError, "Invalid webhook URL: #{e.message}"
+          end
         unless %w[http https].include?(uri.scheme)
           raise ArgumentError, "Webhook URL must be http(s) (got #{uri.scheme.inspect})"
         end

data/lib/parse/webhooks/trigger_audit.rb

@@ -51,12 +51,12 @@ module Parse
       # inside the save handler (Parse Server has no create trigger); the webhook
       # router runs the destroy chain inside the beforeDelete handler.
       CALLBACK_TRIGGER_MAP = {
-        [:save,    :before] => :before_save,
-        [:create,  :before] => :before_save,
-        [:save,    :after]  => :after_save,
-        [:create,  :after]  => :after_save,
+        [:save, :before] => :before_save,
+        [:create, :before] => :before_save,
+        [:save, :after] => :after_save,
+        [:create, :after] => :after_save,
         [:destroy, :before] => :before_delete,
-        [:destroy, :after]  => :after_delete,
+        [:destroy, :after] => :after_delete,
       }.freeze
 
       # ActiveModel callback chains + phases with NO server trigger that can run
@@ -67,10 +67,10 @@ module Parse
       # trigger registration changes that. Surfaced as an informational note, not
       # a fixable gap.
       LOCAL_ONLY_MAP = {
-        [:update,     :before] => :before_update,
-        [:update,     :after]  => :after_update,
+        [:update, :before] => :before_update,
+        [:update, :after] => :after_update,
         [:validation, :before] => :before_validation,
-        [:validation, :after]  => :after_validation,
+        [:validation, :after] => :after_validation,
       }.freeze
 
       # The ActiveModel callback chains we introspect.
@@ -104,12 +104,12 @@ module Parse
 
         def initialize(parse_class:, callbacks:, local_routes:, server_triggers:,
                        findings:, modeled:)
-          @parse_class     = parse_class
-          @callbacks       = callbacks
-          @local_routes    = local_routes
+          @parse_class = parse_class
+          @callbacks = callbacks
+          @local_routes = local_routes
           @server_triggers = server_triggers
-          @findings        = findings
-          @modeled         = modeled
+          @findings = findings
+          @modeled = modeled
         end
 
         # @return [Boolean] true when the class has at least one finding.
@@ -120,12 +120,12 @@ module Parse
         # @return [Hash] a JSON-safe representation of this row.
         def to_h
           {
-            parse_class:     parse_class,
-            modeled:         modeled,
-            callbacks:       callbacks,
-            local_routes:    local_routes,
+            parse_class: parse_class,
+            modeled: modeled,
+            callbacks: callbacks,
+            local_routes: local_routes,
             server_triggers: server_triggers,
-            findings:        findings,
+            findings: findings,
           }
         end
       end
@@ -144,11 +144,11 @@ module Parse
       #   callbacks (e.g. the `_User` default-ACL callback). Off by default to keep
       #   the report focused on app-defined logic.
       def initialize(network: true, client: nil, include_framework: false)
-        @networked         = network
+        @networked = network
         @include_framework = include_framework
-        @client            = client
-        @server_lookup     = network ? fetch_server_triggers : {}
-        @classes           = build_classes
+        @client = client
+        @server_lookup = network ? fetch_server_triggers : {}
+        @classes = build_classes
       end
 
       # @return [Array<Hash>] every finding across all classes, flattened, with the
@@ -164,10 +164,11 @@ module Parse
       def to_h
         {
           networked: networked,
-          classes:   @classes.map(&:to_h),
-          summary:   summary,
+          classes: @classes.map(&:to_h),
+          summary: summary,
         }
       end
+
       alias as_json to_h
 
       # @return [Hash] finding counts keyed by kind, plus class totals.
@@ -175,9 +176,9 @@ module Parse
         counts = Hash.new(0)
         gaps.each { |g| counts[g[:kind]] += 1 }
         {
-          classes_audited:    @classes.size,
+          classes_audited: @classes.size,
           classes_with_issues: @classes.count(&:issues?),
-          findings:           counts,
+          findings: counts,
         }
       end
 
@@ -212,6 +213,7 @@ module Parse
         s[:findings].sort.each { |kind, n| lines << "  #{kind}: #{n}" }
         lines.join("\n")
       end
+
       alias to_s pretty
 
       private
@@ -231,7 +233,7 @@ module Parse
         lookup = Hash.new { |h, k| h[k] = {} }
         client.triggers.results.each do |t|
           next unless t["url"].present?
-          name  = t["triggerName"]
+          name = t["triggerName"]
           klass = t[Parse::Model::KEY_CLASS_NAME] || t["className"]
           next if name.blank? || klass.blank?
           lookup[klass.to_s][name.to_s.underscore.to_sym] = t["url"]
@@ -262,18 +264,18 @@ module Parse
       end
 
       def audit_class(name)
-        klass     = name == "*" ? nil : (Parse::Model.find_class(name) rescue nil)
+        klass = name == "*" ? nil : (Parse::Model.find_class(name) rescue nil)
         callbacks = klass ? collect_callbacks(klass) : {}
-        routes    = collect_local_routes(name)
-        server    = @server_lookup[name] || {}
-        findings  = analyze(name, callbacks, routes, server)
+        routes = collect_local_routes(name)
+        server = @server_lookup[name] || {}
+        findings = analyze(name, callbacks, routes, server)
         ClassAudit.new(
-          parse_class:     name,
-          callbacks:       callbacks,
-          local_routes:    routes,
+          parse_class: name,
+          callbacks: callbacks,
+          local_routes: routes,
           server_triggers: server,
-          findings:        findings,
-          modeled:         !klass.nil?,
+          findings: findings,
+          modeled: !klass.nil?,
         )
       end
 
@@ -373,7 +375,7 @@ module Parse
         end
 
         required.each do |trigger, cb_keys|
-          has_route  = routes.include?(trigger)
+          has_route = routes.include?(trigger)
           has_server = server.key?(trigger)
           missing = []
           missing << :route unless has_route
@@ -381,7 +383,7 @@ module Parse
           next if missing.empty?
 
           findings << {
-            kind:    :callbacks_inert,
+            kind: :callbacks_inert,
             trigger: trigger,
             missing: missing,
             callbacks: cb_keys.sort,
@@ -398,7 +400,7 @@ module Parse
             # Wildcard-only coverage is reported on the "*" row, not here.
             next unless Parse::Webhooks.routes[trigger]&.key?(name)
             findings << {
-              kind:    :route_not_registered,
+              kind: :route_not_registered,
               trigger: trigger,
               message: "Local `webhook :#{trigger}` block for #{name} is not " \
                        "registered as a server trigger — run register_triggers! " \
@@ -410,7 +412,7 @@ module Parse
           server.each_key do |trigger|
             next if routes.include?(trigger)
             findings << {
-              kind:    :orphan_server_trigger,
+              kind: :orphan_server_trigger,
               trigger: trigger,
               message: "Server trigger #{trigger} is registered for #{name} but no " \
                        "local webhook block handles it — every matching operation " \
@@ -426,7 +428,7 @@ module Parse
         end
         if local_only.any?
           findings << {
-            kind:    :local_only_callbacks,
+            kind: :local_only_callbacks,
             callbacks: local_only.sort,
             message: "#{name} has local-only callbacks (#{local_only.sort.join(", ")}) " \
                      "that no server trigger can run — they fire for Ruby-initiated " \
@@ -451,25 +453,24 @@ module Parse
 
       def inert_message(name, trigger, missing, cb_keys)
         callbacks = cb_keys.sort.join(", ")
-        reason =
-          if missing == [:route, :server]
+        reason = if missing == [:route, :server]
             "neither a local `webhook :#{trigger}` block nor a server trigger is " \
-              "registered"
+            "registered"
           elsif missing == [:route]
             "no local `webhook :#{trigger}` block is registered to handle it"
           else # [:server]
             "a local block exists but the #{trigger} server trigger is not registered"
           end
         "#{name} callbacks (#{callbacks}) will NOT run for non-Ruby clients: " \
-          "#{reason}. Register `webhook :#{trigger}` and run register_triggers!."
+        "#{reason}. Register `webhook :#{trigger}` and run register_triggers!."
       end
 
       def finding_glyph(kind)
         case kind
-        when :callbacks_inert       then "GAP "
-        when :route_not_registered  then "GAP "
+        when :callbacks_inert then "GAP "
+        when :route_not_registered then "GAP "
         when :orphan_server_trigger then "WARN"
-        when :local_only_callbacks  then "note"
+        when :local_only_callbacks then "note"
         else "    "
         end
       end
@@ -493,7 +494,7 @@ module Parse
       #   `pretty: true`.
       def trigger_audit(pretty: false, network: true, client: nil, include_framework: false)
         audit = TriggerAudit.new(
-          network: network, client: client, include_framework: include_framework
+          network: network, client: client, include_framework: include_framework,
         )
         pretty ? audit.pretty : audit.to_h
       end

data/lib/parse/webhooks.rb

@@ -182,8 +182,26 @@ module Parse
           raise ArgumentError, "Invalid Webhook registration trigger #{type} #{className}"
         end
 
-        # AfterSave/AfterDelete hooks support more than one
-        if type == :after_save || type == :after_delete
+        # Triggers whose handlers compose instead of replacing one another.
+        #
+        # `after_save` / `after_delete` have always accumulated. The remaining
+        # `after_*` triggers are added because the SDK itself now registers
+        # them for cache invalidation: without this, registering an internal
+        # `after_logout` handler would silently replace an application's own,
+        # with the winner decided by file load order and no warning.
+        #
+        # This is safe only for non-rejectable triggers. Parse Server ignores
+        # their response body, and {#call_route} normalizes their result to
+        # `true` regardless, so `.last` semantics are irrelevant.
+        # {REJECTABLE_NON_OBJECT_TRIGGERS} are deliberately excluded: a
+        # composite of those must deny if ANY handler denies, and folding with
+        # `.last` would discard an earlier rejection.
+        composable = type == :after_save || type == :after_delete ||
+                     (NON_OBJECT_TRIGGERS.include?(type) &&
+                      !REJECTABLE_NON_OBJECT_TRIGGERS.include?(type) &&
+                      type.to_s.start_with?("after_"))
+
+        if composable
           routes[type][className] ||= []
           routes[type][className].push block
         else
@@ -353,7 +371,7 @@ module Parse
             if pre_obj.respond_to?(:apply_field_guards!)
               pre_obj.apply_field_guards!(
                 master: payload.master? || false,
-                is_new: payload.original.blank?
+                is_new: payload.original.blank?,
               )
             end
           end
@@ -777,7 +795,7 @@ module Parse
           else
             if self.logging.present?
               puts "[Webhooks] --> Could not find mapping route for " \
-                   "#{Parse::Middleware::BodyBuilder.redact(payload.to_json)}"
+                "#{Parse::Middleware::BodyBuilder.redact(payload.to_json)}"
             end
           end
 

data/parse-stack-next.gemspec

@@ -6,7 +6,7 @@ require "parse/stack/version"
 Gem::Specification.new do |spec|
   spec.name = "parse-stack-next"
   spec.version = Parse::Stack::VERSION
-  spec.authors =  ["Adrian Curtin", "Anthony Persaud", "Henry Spindell"]
+  spec.authors = ["Adrian Curtin", "Anthony Persaud", "Henry Spindell"]
   spec.email = ["adrian+parse-stack@neurosynq.net"]
 
   spec.summary = %q{Parse Server SDK for Ruby — ORM, queries, auth, and MongoDB-direct access}
@@ -15,11 +15,11 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
 
   spec.metadata = {
-    "homepage_uri"          => "https://github.com/neurosynq/parse-stack-next",
-    "source_code_uri"       => "https://github.com/neurosynq/parse-stack-next",
-    "changelog_uri"         => "https://github.com/neurosynq/parse-stack-next/blob/main/CHANGELOG.md",
-    "bug_tracker_uri"       => "https://github.com/neurosynq/parse-stack-next/issues",
-    "documentation_uri"     => "https://neurosynq.github.io/parse-stack-next/",
+    "homepage_uri" => "https://github.com/neurosynq/parse-stack-next",
+    "source_code_uri" => "https://github.com/neurosynq/parse-stack-next",
+    "changelog_uri" => "https://github.com/neurosynq/parse-stack-next/blob/main/CHANGELOG.md",
+    "bug_tracker_uri" => "https://github.com/neurosynq/parse-stack-next/issues",
+    "documentation_uri" => "https://neurosynq.github.io/parse-stack-next/",
     "rubygems_mfa_required" => "true",
   }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack-next
 version: !ruby/object:Gem::Version
-  version: 5.5.6
+  version: 5.7.0
 platform: ruby
 authors:
 - Adrian Curtin
@@ -225,6 +225,7 @@ files:
 - docs/_config.yml
 - docs/acl_clp_guide.md
 - docs/atlas_vector_search_guide.md
+- docs/caching.md
 - docs/client_sdk_guide.md
 - docs/mcp_guide.md
 - docs/mongodb_direct_guide.md
@@ -242,6 +243,7 @@ files:
 - examples/webhook_server.rb
 - lib/parse-stack-next.rb
 - lib/parse-stack.rb
+- lib/parse/access.rb
 - lib/parse/acl_scope.rb
 - lib/parse/agent.rb
 - lib/parse/agent/approval_gate.rb
@@ -284,8 +286,15 @@ files:
 - lib/parse/atlas_search/result.rb
 - lib/parse/atlas_search/search_builder.rb
 - lib/parse/atlas_search/session.rb
+- lib/parse/authorization.rb
+- lib/parse/cache/invalidation.rb
+- lib/parse/cache/keyspace.rb
+- lib/parse/cache/moneta_surface.rb
 - lib/parse/cache/pool.rb
 - lib/parse/cache/redis.rb
+- lib/parse/cache/scoped_view.rb
+- lib/parse/cache/sub_cache.rb
+- lib/parse/cache/upstream_roles.rb
 - lib/parse/client.rb
 - lib/parse/client/authentication.rb
 - lib/parse/client/batch.rb
@@ -301,16 +310,20 @@ files:
 - lib/parse/console.rb
 - lib/parse/embeddings.rb
 - lib/parse/embeddings/batch_embedder.rb
+- lib/parse/embeddings/binding_audit.rb
 - lib/parse/embeddings/cache.rb
 - lib/parse/embeddings/cohere.rb
 - lib/parse/embeddings/fixture.rb
 - lib/parse/embeddings/image_fetch.rb
 - lib/parse/embeddings/jina.rb
 - lib/parse/embeddings/local_http.rb
+- lib/parse/embeddings/media_file.rb
 - lib/parse/embeddings/openai.rb
 - lib/parse/embeddings/provider.rb
 - lib/parse/embeddings/qwen.rb
 - lib/parse/embeddings/spend_cap.rb
+- lib/parse/embeddings/streaming_body.rb
+- lib/parse/embeddings/video_source.rb
 - lib/parse/embeddings/voyage.rb
 - lib/parse/graphql.rb
 - lib/parse/graphql/scalars.rb