calmlens 0.18.2 → 0.19.0

data/lib/calmlens/hash_lists.rb

@@ -5,12 +5,15 @@ module CalmLens
   # project: a `flag` list reports matches, a `block` list also blocks close matches. Reach it through
   # {ServerClient#hash_lists}.
   class HashLists < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = 'hashLists'
+
     # Lists one page of the project's hash lists, newest first.
     # @option options [String] :cursor the previous page's `nextCursor`
     # @option options [Integer] :page_size 1 to 100, default 50
     # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
     def list(options = {})
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         response = request('GET', project('hash-lists'), query: api, request_options: request)
         valid = response.is_a?(Hash) && response['items'].is_a?(Array)
         raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Invalid hash list page') unless valid
@@ -22,7 +25,7 @@ module CalmLens
     # @option options [String] :hash_list_id
     # @return [Hash] the hash list
     def retrieve(options)
-      call(options) { |api, request| request('GET', list_path(api), request_options: request) }
+      call(options, __method__) { |api, request| request('GET', list_path(api), request_options: request) }
     end
 
     # @option options [String] :name
@@ -30,7 +33,7 @@ module CalmLens
     # @option options [String, nil] :description
     # @return [Hash] the hash list
     def create(options)
-      call(options) { |api, request| request('POST', project('hash-lists'), body: api, request_options: request) }
+      call(options, __method__) { |api, request| request('POST', project('hash-lists'), body: api, request_options: request) }
     end
 
     # Renames a list or changes what its matches do. The new action applies to later uploads.
@@ -40,7 +43,7 @@ module CalmLens
     # @option options [String] :action `flag` or `block`
     # @return [Hash] the hash list
     def update(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('PATCH', list_path(api), body: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -49,7 +52,7 @@ module CalmLens
     # @option options [String] :hash_list_id
     # @return [nil]
     def delete(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('DELETE', list_path(api), request_options: request)
         nil
       end
@@ -61,7 +64,7 @@ module CalmLens
     # @option options [Integer] :page_size 1 to 100, default 50
     # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
     def list_entries(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('GET', "#{list_path(api)}/entries", query: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -74,7 +77,7 @@ module CalmLens
     # @option options [String] :label
     # @return [Hash] the entry
     def add_entry(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('POST', "#{list_path(api)}/entries", body: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -82,7 +85,7 @@ module CalmLens
     # @option options [String] :entry_id
     # @return [nil]
     def remove_entry(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('DELETE', "/hash-list-entries/#{Internal.segment(api['entryId'])}", request_options: request)
         nil
       end

data/lib/calmlens/lenses.rb

@@ -4,12 +4,15 @@ module CalmLens
   # Lens definitions, cached per client. Used through {ServerClient#ensure_lenses} and {ServerClient#ensure_lens}.
   # @api private
   class Lenses < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = nil
+
     def ensure_lenses(options)
-      call(options) { |api, request| @session.ensure_lenses(api['lenses'], request) }
+      call(options, __method__) { |api, request| @session.ensure_lenses(api['lenses'], request) }
     end
 
     def ensure_lens(options)
-      call(options) { |api, request| @session.ensure_lenses([api], request).first }
+      call(options, __method__) { |api, request| @session.ensure_lenses([api], request).first }
     end
   end
   private_constant :Lenses

data/lib/calmlens/option_keys.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Generated by packages/sdk-contract/generate.ts from packages/shared/src/PublicApiSchemas.ts.
+# Do not edit by hand: run `bun packages/sdk-contract/generate.ts`.
+module CalmLens
+  module Internal
+    # The camelCase option keys each method takes, besides `request_options`.
+    OPTION_KEYS = {
+      'assets.batch' => %w[assetIds operation].freeze,
+      'assets.classify' => %w[
+        authorId content context description externalId externalUrl folderId isFinal metadata name part
+        processingOptions sizeInBytes totalSizeInBytes uploadPresetId url visibility
+      ].freeze,
+      'assets.create' => %w[
+        authorId content context description externalId externalUrl folderId isFinal metadata name part
+        processingOptions sizeInBytes totalSizeInBytes uploadPresetId url visibility
+      ].freeze,
+      'assets.createSignedUrl' => %w[assetId expiresInSeconds lens resource transform viewerClaims].freeze,
+      'assets.decide' => %w[assetId confirmPurge decision note].freeze,
+      'assets.delete' => %w[assetId].freeze,
+      'assets.deleteContent' => %w[assetId].freeze,
+      'assets.each' => %w[cursor filter folderId ordering pageSize].freeze,
+      'assets.eachChild' => %w[assetId cursor ordering pageSize].freeze,
+      'assets.explain' => %w[assetId rerun].freeze,
+      'assets.list' => %w[cursor filter folderId ordering pageSize].freeze,
+      'assets.listChildren' => %w[assetId cursor ordering pageSize].freeze,
+      'assets.move' => %w[assetId folderId].freeze,
+      'assets.retrieve' => %w[assetId].freeze,
+      'assets.retry' => %w[assetId].freeze,
+      'assets.search' => %w[limit mode query].freeze,
+      'assets.update' => %w[assetId description externalId externalUrl metadata name tags visibility].freeze,
+      'assets.uploadPart' => %w[assetId part queue].freeze,
+      'ensureLens' => %w[active description identifier name transform type version].freeze,
+      'ensureLenses' => %w[lenses].freeze,
+      'events.each' => %w[cursor pageSize].freeze,
+      'events.eachPage' => %w[cursor pageSize].freeze,
+      'events.list' => %w[cursor pageSize].freeze,
+      'folders.create' => %w[name parentId].freeze,
+      'folders.delete' => %w[folderId].freeze,
+      'folders.list' => %w[cursor ordering pageSize parentId search].freeze,
+      'folders.move' => %w[folderId parentId].freeze,
+      'folders.retrieve' => %w[folderId].freeze,
+      'folders.update' => %w[folderId name].freeze,
+      'hashLists.addEntry' => %w[assetId hash hashListId label quality].freeze,
+      'hashLists.create' => %w[action description name].freeze,
+      'hashLists.delete' => %w[hashListId].freeze,
+      'hashLists.list' => %w[cursor ordering pageSize].freeze,
+      'hashLists.listEntries' => %w[cursor hashListId ordering pageSize].freeze,
+      'hashLists.removeEntry' => %w[entryId].freeze,
+      'hashLists.retrieve' => %w[hashListId].freeze,
+      'hashLists.update' => %w[action description hashListId name].freeze,
+      'policies.applyPreset' => %w[operation policyId presetVersion revision].freeze,
+      'policies.assign' => %w[policyId].freeze,
+      'policies.create' => %w[description name presetId settings].freeze,
+      'policies.delete' => %w[policyId].freeze,
+      'policies.list' => %w[].freeze,
+      'policies.retrieve' => %w[policyId].freeze,
+      'policies.setAutomaticUpdates' => %w[enabled policyId presetVersion revision].freeze,
+      'policies.update' => %w[description name policyId revision settings].freeze,
+      'text.classify' => %w[
+        authorId context description externalId externalUrl folderId metadata name processingOptions text
+        uploadPresetId visibility
+      ].freeze
+    }.freeze
+  end
+end

data/lib/calmlens/policies.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CalmLens
+  # Moderation policies belong to the project's organisation and its projects share them. Every
+  # change sends the policy's `revision`, so a policy changed since is refused with
+  # `policy/revision-conflict`. Through a project's key you can change only policies no other
+  # project uses or owns. Reach it through {ServerClient#policies}.
+  class Policies < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = 'policies'
+
+    # Lists the organisation's policies, oldest first, and the ID of the one the project uses.
+    # @return [Hash] `policies` and `projectPolicyId`
+    def list(options = {})
+      call(options, __method__) { |_api, request| request('GET', project('policies'), request_options: request) }
+    end
+
+    # @option options [String] :policy_id
+    # @return [Hash] the policy
+    def retrieve(options)
+      call(options, __method__) { |api, request| request('GET', policy_path(api), request_options: request) }
+    end
+
+    # Creates a policy from `settings` (defining every category) with a `name`, or a copy of the
+    # latest release of a built-in preset with `preset_id`. It moderates nothing until it is
+    # assigned to a project or named on an upload preset.
+    # @option options [String] :name required with `settings`; a preset copy defaults to its name
+    # @option options [String] :description
+    # @option options [Hash] :settings
+    # @option options [String] :preset_id `general-community`, `children-platform`, `education-support`
+    #   or `wholesome-community`
+    # @return [Hash] the policy
+    def create(options)
+      call(options, __method__) { |api, request| request('POST', project('policies'), body: api, request_options: request) }
+    end
+
+    # Changes the name, description or settings (complete, defining every category); later
+    # moderation uses them. Saving a policy that follows automatic updates pins it as a copy.
+    # @option options [String] :policy_id
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [String] :name
+    # @option options [String] :description
+    # @option options [Hash] :settings
+    # @return [Hash] the policy
+    def update(options)
+      call(options, __method__) do |api, request|
+        request('PATCH', policy_path(api), body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Resets a preset copy to its pinned preset version, or updates an unchanged copy to the latest
+    # preset release.
+    # @option options [String] :policy_id
+    # @option options [String] :operation `reset` or `update`
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [Integer] :preset_version `preset.version` to reset, `preset.latestVersion` to update
+    # @return [Hash] the policy
+    def apply_preset(options)
+      call(options, __method__) do |api, request|
+        request('POST', "#{policy_path(api)}/preset", body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Switches automatic updates on or off for the project's preset policy. Switching on replaces
+    # the saved copy with the latest preset settings under the same ID; switching off pins the
+    # current preset version as a copy with unchanged settings.
+    # @option options [String] :policy_id
+    # @option options [Boolean] :enabled
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [Integer] :preset_version the preset's `latestVersion`
+    # @return [Hash] the policy
+    def set_automatic_updates(options) # rubocop:disable Naming/AccessorMethodName -- the shared SDK surface name
+      call(options, __method__) do |api, request|
+        request('PUT', "#{policy_path(api)}/automatic-updates", body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Deletes a policy that no project or upload preset uses.
+    # @option options [String] :policy_id
+    # @return [nil]
+    def delete(options)
+      call(options, __method__) do |api, request|
+        request('DELETE', policy_path(api), request_options: request)
+        nil
+      end
+    end
+
+    # Chooses the policy the project moderates with. Later uploads use it, except those through an
+    # upload preset that names its own policy.
+    # @option options [String] :policy_id
+    # @return [Hash] the policy
+    def assign(options)
+      call(options, __method__) { |api, request| request('PUT', project('policy'), body: api, request_options: request) }
+    end
+
+    private
+
+    def policy_path(api) = project("policies/#{Internal.segment(api['policyId'])}")
+  end
+end

data/lib/calmlens/resource.rb

@@ -15,8 +15,21 @@ module CalmLens
 
     private
 
+    # The option keys of methods that send no request of their own, or take options of their own
+    # beside a request's; Internal::OPTION_KEYS, generated from the API, has the rest.
+    LOCAL_OPTION_KEYS = {
+      'assets.waitForDecision' => %w[assetId timeout].freeze,
+      'cdn.getAssetUrl' => %w[assetIdentifier lens resource transform viewerClaims].freeze,
+      'cdn.serve' => %w[assetIdentifier init lens resource transform viewerClaims].freeze,
+      'uploadTokens.sign' => %w[expiresInSeconds externalId uploadPresetId].freeze
+    }.freeze
+    private_constant :LOCAL_OPTION_KEYS
+
     # Runs a public method: splits options, and raises every argument problem as {InvalidArgumentError}.
-    def call(options)
+    # `method` names the public method: an option it doesn't take, such as a misspelt one, raises
+    # `sdk/invalid-argument` instead of being silently dropped.
+    def call(options, method)
+      check_option_keys(options, [self.class::OPERATIONS, Internal.camelize(method)].compact.join('.'))
       api, request = Internal.options(options)
       yield api, request
     rescue Error
@@ -25,6 +38,18 @@ module CalmLens
       raise InvalidArgumentError.new(SdkErrorCodes::INVALID_ARGUMENT, e.message), cause: e
     end
 
+    def check_option_keys(options, operation)
+      return unless options.is_a?(Hash)
+
+      allowed = LOCAL_OPTION_KEYS.fetch(operation) { Internal::OPTION_KEYS.fetch(operation) }
+      unknown = options.keys.reject do |key|
+        %w[request_options requestOptions].include?(key.to_s) || allowed.include?(Internal.camelize(key))
+      end
+      return if unknown.empty?
+
+      raise Internal.invalid("Unknown option#{'s' if unknown.size > 1} for #{operation}: #{unknown.join(', ')}")
+    end
+
     def request(...) = @session.request(...)
     def project(path) = @session.project(path)
 

data/lib/calmlens/server_client.rb

@@ -25,6 +25,11 @@ module CalmLens
     RETRY_AFTER_MAX = 60
     # The largest response body read, in bytes (32 MiB).
     DEFAULT_MAX_RESPONSE_BYTES = 32 * 1024 * 1024
+    # Content larger than this many bytes is uploaded in parts of this size (8 MiB).
+    DEFAULT_PART_SIZE_BYTES = 8 * 1024 * 1024
+    # The smallest and largest `part_size_bytes`: every part but the last is at least 5 MiB.
+    MIN_PART_SIZE_BYTES = 5 * 1024 * 1024
+    MAX_PART_SIZE_BYTES = 64 * 1024 * 1024
     # The most lens definitions {#ensure_lenses} sends in one request.
     ENSURE_LENSES_MAX_PER_REQUEST = 100
 
@@ -34,6 +39,8 @@ module CalmLens
     attr_reader :folders
     # @return [HashLists]
     attr_reader :hash_lists
+    # @return [Policies]
+    attr_reader :policies
     # @return [Text]
     attr_reader :text
     # @return [UploadTokens]
@@ -62,14 +69,18 @@ module CalmLens
     #   `Retry-After`. Other writes are never retried. 0 disables retries.
     # @param retry_base_delay [Numeric] seconds before the first retry when the API gives no
     #   `Retry-After`; later retries wait up to twice as long each time, at most 8 seconds.
+    # @param part_size_bytes [Integer] content larger than this many bytes whose size the client knows
+    #   and can read again (a binary String, base64, or a File, StringIO or other seekable IO) is
+    #   uploaded in parts of this size: each part is retried on its own, and calling again with the
+    #   same `idempotency_key` resumes an interrupted upload. From 5 MiB to 64 MiB; default 8 MiB.
     # @param transport [#call, nil] a custom {Transport}; defaults to {Transport::NetHTTP}.
     # @raise [ConfigurationError] `sdk/invalid-config` for a missing or malformed setting.
     def initialize(api_key:, project_id:, base_url: DEFAULT_BASE_URL, cdn_base_url: DEFAULT_CDN_BASE_URL,
                    timeout: DEFAULT_TIMEOUT, open_timeout: DEFAULT_OPEN_TIMEOUT, upload_timeout: nil,
                    max_retries: DEFAULT_MAX_RETRIES, retry_base_delay: DEFAULT_RETRY_BASE_DELAY,
-                   max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES, transport: nil)
+                   max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES, part_size_bytes: DEFAULT_PART_SIZE_BYTES, transport: nil)
       check_config(api_key, project_id, timeout, open_timeout, max_retries, retry_base_delay, transport)
-      check_limits(upload_timeout, max_response_bytes)
+      check_limits(upload_timeout, max_response_bytes, part_size_bytes)
       @project_id = project_id
       @base_url = ServerClient.check_url(base_url, 'base_url')
       @cdn_base_url = ServerClient.check_url(cdn_base_url, 'cdn_base_url')
@@ -77,10 +88,11 @@ module CalmLens
                              cdn_base_url: @cdn_base_url, timeout: timeout, open_timeout: open_timeout,
                              max_retries: max_retries, retry_base_delay: retry_base_delay,
                              max_response_bytes: max_response_bytes, upload_timeout: upload_timeout,
-                             transport: transport || Transport::NetHTTP.new)
+                             part_size_bytes: part_size_bytes, transport: transport || Transport::NetHTTP.new)
       @assets = Assets.new(@session)
       @folders = Folders.new(@session)
       @hash_lists = HashLists.new(@session)
+      @policies = Policies.new(@session)
       @text = Text.new(@session, @assets)
       @upload_tokens = UploadTokens.new(@session, api_key)
       @events = Events.new(@session)
@@ -107,11 +119,11 @@ module CalmLens
       nil
     end
 
-    # Creates or updates named lenses (saved transform pipelines) and returns them. Definitions
+    # Creates or updates named lenses (saved transforms) and returns them. Definitions
     # this client already saved are not sent again. Supplying the same definition and version is
     # idempotent; changing a lens needs a higher `version`. More than 100 new definitions are sent in
     # consecutive requests, in order.
-    # @option options [Array<Hash>] :lenses `[{identifier:, name:, type:, version:, transforms:, ...}]`
+    # @option options [Array<Hash>] :lenses `[{identifier:, name:, type:, version:, transform:, ...}]`
     # @return [Array<Hash>] the saved lenses, in the given order.
     def ensure_lenses(options) = @lenses.ensure_lenses(options)
 
@@ -135,10 +147,15 @@ module CalmLens
 
     private
 
-    def check_limits(upload_timeout, max_response_bytes)
+    def check_limits(upload_timeout, max_response_bytes, part_size_bytes)
       unless upload_timeout.nil? || Internal.positive?(upload_timeout)
         raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'upload_timeout must be nil or a positive number of seconds')
       end
+      unless part_size_bytes.is_a?(Integer) && part_size_bytes.between?(MIN_PART_SIZE_BYTES, MAX_PART_SIZE_BYTES)
+        raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG,
+                                     "part_size_bytes must be an Integer from #{MIN_PART_SIZE_BYTES} (5 MiB) to " \
+                                     "#{MAX_PART_SIZE_BYTES} (64 MiB)")
+      end
       return if max_response_bytes.is_a?(Integer) && max_response_bytes.positive?
 
       raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'max_response_bytes must be a positive Integer')

data/lib/calmlens/session.rb

@@ -25,13 +25,16 @@ module CalmLens
     end
 
     attr_reader :project_id, :base_url, :cdn_base_url
+    # Content larger than this many bytes that can be read again is uploaded in parts of this size.
+    attr_reader :part_size_bytes
     # Leaves the upload size checks the API also makes (part and image sizes) to the API, so an
     # offline stand-in answers them like the API does. {MockServerClient} sets it.
     attr_accessor :defer_upload_checks
 
     def initialize(api_key:, project_id:, base_url:, cdn_base_url:, timeout:, open_timeout:, max_retries:,
-                   retry_base_delay:, max_response_bytes:, upload_timeout:, transport:)
+                   retry_base_delay:, max_response_bytes:, upload_timeout:, part_size_bytes:, transport:)
       @api_key = api_key
+      @part_size_bytes = part_size_bytes
       @project_id = project_id
       @base_url = base_url
       @cdn_base_url = cdn_base_url
@@ -161,10 +164,10 @@ module CalmLens
     private
 
     # The fields that identify a lens definition, as canonical JSON: an unset description or
-    # transforms list is the same definition as an explicit null.
+    # transform is the same definition as an explicit null.
     def lens_key(lens)
       fields = { 'identifier' => lens['identifier'], 'name' => lens['name'], 'description' => lens['description'],
-                 'type' => lens['type'], 'transforms' => lens['transforms'] }
+                 'type' => lens['type'], 'transform' => lens['transform'] }
       %w[active version].each { |name| fields[name] = lens[name] if lens.key?(name) }
       JSON.generate(canonical(fields))
     end

data/lib/calmlens/testing/classification.rb

@@ -17,5 +17,8 @@ module CalmLens
       "personal-information" => ["personal-information-contact", "personal-information-email", "personal-information-phone", "personal-information-government-id", "personal-information-financial", "personal-information-location", "personal-information-identifiers", "personal-information-credentials", "personal-information-request", "personal-information-self-disclosure", "personal-information-third-party", "personal-information-historical", "personal-information-documentary", "personal-information-educational", "personal-information-fictional", "personal-information-support-prevention"].freeze,
       "profanity" => ["profanity-mild", "profanity-strong", "profanity-slurs", "profanity-obfuscated", "profanity-historical", "profanity-documentary", "profanity-educational", "profanity-fictional", "profanity-support-prevention"].freeze,
     }.freeze
+
+    # Qualifiers the input type sets, which a test input scenario cannot list.
+    INPUT_QUALIFIERS = ["sexual-text", "violence-text"].freeze
   end
 end

data/lib/calmlens/testing/fake_api.rb

@@ -59,11 +59,15 @@ module CalmLens
       MAX_DECISION_NOTE_LENGTH = 1499
       RESOURCES = %w[original rendered placeholder].freeze
       MIN_PART = 5 * 1024 * 1024
-      MIN_MULTIPART_IMAGE = 10 * 1024 * 1024
       MAX_MULTIPART_IMAGE = 20 * 1024 * 1024
+      # Like the API: an upload has at most this many parts.
+      MAX_PARTS = 10_000
       # The ThumbHash the mock gives every classified image, standing in for one computed from its
       # pixels. The `placeholder` resource serves it as a PNG, like the CDN.
       THUMBHASH = '1QcSHQRnh493V4dIh4eXh1h4kJUI'
+      # The built-in presets the mock knows, by display name.
+      PRESET_NAMES = { 'general-community' => 'General', 'children-platform' => 'Kids',
+                       'education-support' => 'Learning and support', 'wholesome-community' => 'Teen-safe' }.freeze
       # Like the API: 1 to 255 printable ASCII characters, without a space at either end.
       IDEMPOTENCY_KEY = /\A[\x21-\x7e](?:[\x20-\x7e]{0,253}[\x21-\x7e])?\z/
       # Content a browser could run as a document, which the CDN serves as a download.
@@ -83,6 +87,10 @@ module CalmLens
         @grants = grants
         @state = State.new(assets: {}, folders: {}, content: {}, events: [], lenses: {}, uploads: {}, idempotency: {},
                            hash_lists: {}, hash_list_entries: {})
+        # Stored policies (the API's shape without `projectIds` and `preset.latestVersion`, plus their
+        # reset `baseline`) and the one the project moderates with.
+        @policies = {}
+        @project_policy_id = nil
         @request_count = 0
       end
 
@@ -304,6 +312,10 @@ module CalmLens
         in ['POST', ['folders'], _] then create_folder(json)
         in ['GET', ['hash-lists'], _] then page(project_hash_lists, query, JSON.generate([@project_id]))
         in ['POST', ['hash-lists'], _] then create_hash_list(json)
+        in ['GET', ['policies'], _] then policy_list
+        in ['POST', ['policies'], _] then create_policy(json)
+        in ['PUT', ['policy'], _] then show_policy(assign_policy(json))
+        in [_, ['policies', String => policy_id, *rest], _] then policy(method, policy_id, rest, json)
         in ['GET', ['assets'], _] then list(query)
         in ['GET', ['assets', 'search'], _] then search(query)
         in ['POST', ['assets', 'batch'], _] then batch(json)
@@ -399,11 +411,12 @@ module CalmLens
       def project_folders = @state.folders.values.select { |item| item['projectId'] == @project_id }
 
       # Like the API: without a cursor, no events and a `nextCursor` for now; with one, up to `pageSize`
-      # events added since, oldest first. `nextCursor` is never nil.
+      # events added since, oldest first. `nextCursor` is never nil. The mock's key holds every permission,
+      # so no event type is excluded.
       def events(query)
         size = check_range(query.fetch('pageSize', DEFAULT_PAGE_SIZE), 'pageSize', MAX_PAGE_SIZE)
         feed = @state.events
-        return { 'items' => [], 'nextCursor' => "mock_#{feed.size}", 'hasMore' => false } unless query['cursor']
+        return { 'items' => [], 'nextCursor' => "mock_#{feed.size}", 'hasMore' => false, 'excludedTypes' => [] } unless query['cursor']
 
         match = query['cursor'].to_s.match(/\Amock_(\d+)\z/)
         position = match && Integer(match[1], 10)
@@ -411,7 +424,7 @@ module CalmLens
 
         taken = feed[position, size]
         following = position + taken.size
-        { 'items' => taken, 'nextCursor' => "mock_#{following}", 'hasMore' => following < feed.size }
+        { 'items' => taken, 'nextCursor' => "mock_#{following}", 'hasMore' => following < feed.size, 'excludedTypes' => [] }
       end
 
       # Saves lenses in order, like the API: an unchanged definition returns the stored lens, a
@@ -429,7 +442,7 @@ module CalmLens
         end
 
         same = %w[name type active].all? { |key| old[key] == definition[key] } &&
-               old['description'] == definition['description'] && canonical(old['transforms']) == canonical(definition['transforms'])
+               old['description'] == definition['description'] && canonical(old['transform']) == canonical(definition['transform'])
         return old if same && old['version'] == definition['version']
         if definition['version'].to_i > old['version'].to_i
           return @state.lenses[old['identifier']] =
@@ -533,12 +546,9 @@ module CalmLens
         }
       end
 
-      # Like the API: image uploads in parts total 10 MiB (checked at the last part) to 20 MiB.
-      def image_size_error(type, size, final)
-        return unless type == 'image'
-        return ErrorCodes::MULTIPART_IMAGE_TOO_LARGE if size > MAX_MULTIPART_IMAGE
-
-        ErrorCodes::MULTIPART_IMAGE_TOO_SMALL if final && size < MIN_MULTIPART_IMAGE
+      # Like the API: image uploads in parts total at most 20 MiB, at any size below that.
+      def image_size_error(type, size, _final)
+        ErrorCodes::MULTIPART_IMAGE_TOO_LARGE if type == 'image' && size > MAX_MULTIPART_IMAGE
       end
 
       # Like the API: the parts may not overshoot a declared total, and must reach it at the end.
@@ -793,7 +803,7 @@ module CalmLens
         fail!(ErrorCodes::UPLOAD_NOT_OPEN) unless item['upload']['status'] == 'uploading'
         number = query['partNumber']
         expected = item['upload']['partsReceived'].to_i + 1
-        unless number == expected
+        unless number == expected && number <= MAX_PARTS
           fail!(ErrorCodes::INVALID_UPLOAD_PART_NUMBER, "Expected part #{expected}",
                 details: { 'expectedPartNumber' => expected, 'receivedPartNumber' => number })
         end
@@ -877,6 +887,122 @@ module CalmLens
         touch(item.merge!('parentId' => parent_id))
       end
 
+      # Policies: the project starts on its General preset policy, following automatic updates. The
+      # mock holds no built-in preset settings: a preset's settings are `{ 'categorySettings' => {} }`
+      # at version 1, and uploads are never decided by a policy.
+      def new_policy(name, settings, description: '', automatic_updates: false, preset: nil)
+        now = @now.call
+        item = { 'id' => @create_id.call('pol'), 'name' => name, 'description' => description, 'settings' => settings,
+                 'revision' => 1, 'automaticUpdates' => automatic_updates, 'preset' => preset,
+                 'baseline' => deep_copy(settings), 'createdAt' => now, 'updatedAt' => now }
+        @policies[item['id']] = item
+      end
+
+      def ensure_policies
+        return if @project_policy_id
+
+        preset = { 'id' => 'general-community', 'version' => 1, 'projectId' => @project_id }
+        @project_policy_id = new_policy(PRESET_NAMES['general-community'], { 'categorySettings' => {} },
+                                        automatic_updates: true, preset: preset)['id']
+      end
+
+      # A stored policy as the API shows it.
+      def show_policy(item)
+        shown = item.except('baseline')
+        shown['preset'] = item['preset'].merge('latestVersion' => 1) if item['preset']
+        shown.merge('projectIds' => item['id'] == @project_policy_id ? [@project_id] : [])
+      end
+
+      def find_policy(id)
+        ensure_policies
+        @policies[id] || fail!(ErrorCodes::POLICY_NOT_FOUND)
+      end
+
+      def policy_list
+        ensure_policies
+        { 'policies' => @policies.values.map { |item| show_policy(item) }, 'projectPolicyId' => @project_policy_id }
+      end
+
+      def create_policy(json)
+        ensure_policies
+        name, preset_id, settings = json.values_at('name', 'presetId', 'settings')
+        named = name.is_a?(String) && !name.strip.empty?
+        if settings.nil? == preset_id.nil? || (preset_id && !PRESET_NAMES.key?(preset_id)) || (preset_id.nil? && !named)
+          fail!(ErrorCodes::INVALID_VALUE, 'Send settings with a name, or presetId')
+        end
+        description = json['description'].is_a?(String) ? json['description'] : ''
+        item = if preset_id
+                 origin = { 'id' => preset_id, 'version' => 1, 'projectId' => nil }
+                 new_policy(named ? name.strip : PRESET_NAMES[preset_id], { 'categorySettings' => {} },
+                            description: description, preset: origin)
+               else
+                 new_policy(name.strip, settings, description: description)
+               end
+        # Like the API, a new policy is 201 Created.
+        respond(201, deep_copy(show_policy(item)))
+      end
+
+      def assign_policy(json)
+        item = find_policy(json['policyId'].to_s)
+        @project_policy_id = item['id']
+        item
+      end
+
+      # Saves new values under the next revision, once `revision` is the current one.
+      def save_policy(item, revision, values)
+        fail!(ErrorCodes::POLICY_REVISION_CONFLICT) unless revision.is_a?(Integer) && revision == item['revision']
+
+        item.merge!(values, 'revision' => item['revision'] + 1, 'updatedAt' => @now.call)
+        show_policy(item)
+      end
+
+      def policy(method, id, rest, json)
+        item = find_policy(id)
+        case [method, rest]
+        in ['GET', []] then show_policy(item)
+        in ['PATCH', []] then update_policy(item, json)
+        in ['DELETE', []]
+          fail!(ErrorCodes::POLICY_IN_USE) if item['id'] == @project_policy_id
+          @policies.delete(id)
+          {}
+        in ['POST', ['preset']] then apply_policy_preset(item, json)
+        in ['PUT', ['automatic-updates']] then set_policy_automatic_updates(item, json)
+        else route_not_found!(method, ['policies', id, *rest])
+        end
+      end
+
+      def update_policy(item, json)
+        values = %w[name description].select { |key| json[key].is_a?(String) }
+                                     .to_h { |key| [key, key == 'name' ? json[key].strip : json[key]] }
+        values['settings'] = json['settings'] if json.key?('settings')
+        # Saving a policy that follows its preset pins it as a copy.
+        save_policy(item, json['revision'], values.merge('automaticUpdates' => false))
+      end
+
+      def apply_policy_preset(item, json)
+        preset = item['preset']
+        fail!(ErrorCodes::POLICY_NO_PRESET) if preset.nil? || item['automaticUpdates']
+        fail!(ErrorCodes::POLICY_PRESET_VERSION_CONFLICT) unless json['presetVersion'] == preset['version']
+        # The mock's presets have one release, so an update never has a newer one to apply.
+        fail!(ErrorCodes::POLICY_PRESET_UPDATE_UNAVAILABLE) if json['operation'] == 'update'
+
+        save_policy(item, json['revision'], 'settings' => deep_copy(item['baseline']))
+      end
+
+      def set_policy_automatic_updates(item, json)
+        enabled = json['enabled'] == true
+        preset = item['preset']
+        if preset.nil? || preset['projectId'] != @project_id || item['automaticUpdates'] == enabled
+          fail!(ErrorCodes::POLICY_AUTOMATIC_UPDATES_UNAVAILABLE)
+        end
+        fail!(ErrorCodes::POLICY_REVISION_CONFLICT) unless json['revision'] == item['revision']
+        fail!(ErrorCodes::POLICY_PRESET_VERSION_CONFLICT) unless json['presetVersion'] == 1
+
+        values = { 'automaticUpdates' => enabled }
+        values.merge!('name' => PRESET_NAMES[preset['id']], 'description' => '', 'settings' => deep_copy(item['baseline'])) if enabled
+        save_policy(item, json['revision'], values)
+      end
+
       # Hash lists and their entries. Uploads are not compared with them.
       def project_hash_lists = @state.hash_lists.values.select { |item| item['projectId'] == @project_id }