@giveitsmaller/contracts 0.41.0 → 0.43.0

package/dist/operations/text_watermark.js

@@ -20,3 +20,45 @@ export var TextWatermarkImageAnchor;
     TextWatermarkImageAnchor["BottomCenter"] = "bottom_center";
     TextWatermarkImageAnchor["BottomRight"] = "bottom_right";
 })(TextWatermarkImageAnchor || (TextWatermarkImageAnchor = {}));
+export var TextWatermarkImageTiffFontFamily;
+(function (TextWatermarkImageTiffFontFamily) {
+    TextWatermarkImageTiffFontFamily["LiberationSans"] = "liberation_sans";
+})(TextWatermarkImageTiffFontFamily || (TextWatermarkImageTiffFontFamily = {}));
+export var TextWatermarkImageTiffWatermarkMode;
+(function (TextWatermarkImageTiffWatermarkMode) {
+    TextWatermarkImageTiffWatermarkMode["Single"] = "single";
+    TextWatermarkImageTiffWatermarkMode["Tiled"] = "tiled";
+})(TextWatermarkImageTiffWatermarkMode || (TextWatermarkImageTiffWatermarkMode = {}));
+export var TextWatermarkImageTiffAnchor;
+(function (TextWatermarkImageTiffAnchor) {
+    TextWatermarkImageTiffAnchor["TopLeft"] = "top_left";
+    TextWatermarkImageTiffAnchor["TopCenter"] = "top_center";
+    TextWatermarkImageTiffAnchor["TopRight"] = "top_right";
+    TextWatermarkImageTiffAnchor["CenterLeft"] = "center_left";
+    TextWatermarkImageTiffAnchor["Center"] = "center";
+    TextWatermarkImageTiffAnchor["CenterRight"] = "center_right";
+    TextWatermarkImageTiffAnchor["BottomLeft"] = "bottom_left";
+    TextWatermarkImageTiffAnchor["BottomCenter"] = "bottom_center";
+    TextWatermarkImageTiffAnchor["BottomRight"] = "bottom_right";
+})(TextWatermarkImageTiffAnchor || (TextWatermarkImageTiffAnchor = {}));
+export var TextWatermarkImageBmpFontFamily;
+(function (TextWatermarkImageBmpFontFamily) {
+    TextWatermarkImageBmpFontFamily["LiberationSans"] = "liberation_sans";
+})(TextWatermarkImageBmpFontFamily || (TextWatermarkImageBmpFontFamily = {}));
+export var TextWatermarkImageBmpWatermarkMode;
+(function (TextWatermarkImageBmpWatermarkMode) {
+    TextWatermarkImageBmpWatermarkMode["Single"] = "single";
+    TextWatermarkImageBmpWatermarkMode["Tiled"] = "tiled";
+})(TextWatermarkImageBmpWatermarkMode || (TextWatermarkImageBmpWatermarkMode = {}));
+export var TextWatermarkImageBmpAnchor;
+(function (TextWatermarkImageBmpAnchor) {
+    TextWatermarkImageBmpAnchor["TopLeft"] = "top_left";
+    TextWatermarkImageBmpAnchor["TopCenter"] = "top_center";
+    TextWatermarkImageBmpAnchor["TopRight"] = "top_right";
+    TextWatermarkImageBmpAnchor["CenterLeft"] = "center_left";
+    TextWatermarkImageBmpAnchor["Center"] = "center";
+    TextWatermarkImageBmpAnchor["CenterRight"] = "center_right";
+    TextWatermarkImageBmpAnchor["BottomLeft"] = "bottom_left";
+    TextWatermarkImageBmpAnchor["BottomCenter"] = "bottom_center";
+    TextWatermarkImageBmpAnchor["BottomRight"] = "bottom_right";
+})(TextWatermarkImageBmpAnchor || (TextWatermarkImageBmpAnchor = {}));

package/dist/operations/text_watermark.metadata.js

@@ -42,5 +42,87 @@ export const textWatermarkMetadata = {
             },
             per_input_options: {},
         },
+        image_tiff: {
+            availability: 'planned',
+            processing_class: {},
+            per_mime_availability: {},
+            options: {
+                text: {
+                    per_value_availability: {},
+                },
+                font_size: {
+                    per_value_availability: {},
+                },
+                color: {
+                    per_value_availability: {},
+                },
+                font_family: {
+                    per_value_availability: {},
+                },
+                rotation: {
+                    per_value_availability: {},
+                },
+                watermark_mode: {
+                    per_value_availability: {},
+                },
+                tile_spacing: {
+                    per_value_availability: {},
+                },
+                anchor: {
+                    per_value_availability: {},
+                },
+                margin_x: {
+                    per_value_availability: {},
+                },
+                margin_y: {
+                    per_value_availability: {},
+                },
+                opacity: {
+                    per_value_availability: {},
+                },
+            },
+            per_input_options: {},
+        },
+        image_bmp: {
+            availability: 'planned',
+            processing_class: {},
+            per_mime_availability: {},
+            options: {
+                text: {
+                    per_value_availability: {},
+                },
+                font_size: {
+                    per_value_availability: {},
+                },
+                color: {
+                    per_value_availability: {},
+                },
+                font_family: {
+                    per_value_availability: {},
+                },
+                rotation: {
+                    per_value_availability: {},
+                },
+                watermark_mode: {
+                    per_value_availability: {},
+                },
+                tile_spacing: {
+                    per_value_availability: {},
+                },
+                anchor: {
+                    per_value_availability: {},
+                },
+                margin_x: {
+                    per_value_availability: {},
+                },
+                margin_y: {
+                    per_value_availability: {},
+                },
+                opacity: {
+                    per_value_availability: {},
+                },
+            },
+            per_input_options: {},
+        },
     },
 };

package/dist/operations/thumbnail.d.ts

@@ -14,6 +14,25 @@ export interface ThumbnailImageOptions {
     fit?: ThumbnailImageFit;
     format?: ThumbnailImageFormat;
     quality?: number;
+    background?: string;
+}
+export declare enum ThumbnailImageSvgFit {
+    Max = "max",
+    Crop = "crop",
+    Scale = "scale"
+}
+export declare enum ThumbnailImageSvgFormat {
+    Jpg = "jpg",
+    Png = "png",
+    Webp = "webp"
+}
+export interface ThumbnailImageSvgOptions {
+    width: number;
+    height: number;
+    fit?: ThumbnailImageSvgFit;
+    format?: ThumbnailImageSvgFormat;
+    quality?: number;
+    background?: string;
 }
 export declare enum ThumbnailVideoFit {
     Max = "max",

package/dist/operations/thumbnail.js

@@ -11,6 +11,18 @@ export var ThumbnailImageFormat;
     ThumbnailImageFormat["Png"] = "png";
     ThumbnailImageFormat["Webp"] = "webp";
 })(ThumbnailImageFormat || (ThumbnailImageFormat = {}));
+export var ThumbnailImageSvgFit;
+(function (ThumbnailImageSvgFit) {
+    ThumbnailImageSvgFit["Max"] = "max";
+    ThumbnailImageSvgFit["Crop"] = "crop";
+    ThumbnailImageSvgFit["Scale"] = "scale";
+})(ThumbnailImageSvgFit || (ThumbnailImageSvgFit = {}));
+export var ThumbnailImageSvgFormat;
+(function (ThumbnailImageSvgFormat) {
+    ThumbnailImageSvgFormat["Jpg"] = "jpg";
+    ThumbnailImageSvgFormat["Png"] = "png";
+    ThumbnailImageSvgFormat["Webp"] = "webp";
+})(ThumbnailImageSvgFormat || (ThumbnailImageSvgFormat = {}));
 export var ThumbnailVideoFit;
 (function (ThumbnailVideoFit) {
     ThumbnailVideoFit["Max"] = "max";

package/dist/operations/thumbnail.metadata.js

@@ -28,6 +28,35 @@ export const thumbnailMetadata = {
                 quality: {
                     per_value_availability: {},
                 },
+                background: {
+                    per_value_availability: {},
+                },
+            },
+            per_input_options: {},
+        },
+        image_svg: {
+            availability: 'planned',
+            processing_class: {},
+            per_mime_availability: {},
+            options: {
+                width: {
+                    per_value_availability: {},
+                },
+                height: {
+                    per_value_availability: {},
+                },
+                fit: {
+                    per_value_availability: {},
+                },
+                format: {
+                    per_value_availability: {},
+                },
+                quality: {
+                    per_value_availability: {},
+                },
+                background: {
+                    per_value_availability: {},
+                },
             },
             per_input_options: {},
         },

package/dist/operations/video_watermark.metadata.js

@@ -4,7 +4,7 @@ export const videoWatermarkMetadata = {
     features: {
         multi_overlay_stack: {
             availability: 'planned',
-            description: 'Allow up to 8 overlay inputs per job (currently capped at 1 overlay). Per-overlay placement via JobInputV2.per_input_options. Lambda-side support not yet confirmed; tagged planned per ADR-0001 §1.4. Mirrors the same-named feature on `image_watermark`. ',
+            description: 'Allow up to 8 overlay inputs per job (currently capped at 1 overlay). Per-overlay placement via per-input placement options. Backend support not yet confirmed; tagged planned. Mirrors the same-named feature on `image_watermark`. ',
         },
     },
     mime_groups: {

package/openapi/api.yaml

@@ -89,7 +89,7 @@ info:
     of truth instead of hardcoding magic numbers. A runtime
     `GET /api/uploads/limits` endpoint for dynamic discovery
     (per-tier / per-environment overrides) is a deferred follow-up.
-  version: 2.117.0
+  version: 2.124.0
   contact:
     name: API Support
 
@@ -7198,8 +7198,8 @@ components:
         - thumbnail_office: Office document (DOCX/XLSX/PPTX/ODT/ODS/ODP)
           thumbnail sub-type. Backed by a dedicated LibreOffice Lambda.
           Emitted by the publisher for office-document inputs.
-        - image_watermark: Image overlay onto a base IMAGE asset. Multi-input (Path B with role: base + overlay). Each input is a `MultiInputSource` (external_import / connection / job_output — no upload-direct); an uploaded base or overlay enters via a `passthrough` source job referenced by `job_output`. Stable for static-image bases (jpeg/png/webp); animated GIF is advertised as `planned` via the `image_gif` mime_group — dispatch returns `feature_not_available` (422) until Lambda support ships. Video bases are NOT supported by image_watermark — use the dedicated `video_watermark` operation per ADR-0013. Per ADR-0004 + I4-CONS + I5 (Trello AKZiOXnd).
-        - text_watermark: Text overlay rendered onto an image (Liberation Sans). Single-input. Per ADR-0004 + I4-CONS.
+        - image_watermark: Image overlay onto a base IMAGE asset. Multi-input (Path B with role: base + overlay). Each input is a `MultiInputSource` (external_import / connection / job_output — no upload-direct); an uploaded base or overlay enters via a `passthrough` source job referenced by `job_output`. Stable for static-image bases (jpeg/png/webp); animated GIF (`image_gif`), TIFF (`image_tiff`) and BMP (`image_bmp`) bases are advertised as `planned` via parallel mime_groups — dispatch returns `feature_not_available` (422) until Lambda support ships. Video bases are NOT supported by image_watermark — use the dedicated `video_watermark` operation per ADR-0013. Per ADR-0004 + I4-CONS + I5 (Trello AKZiOXnd).
+        - text_watermark: Text overlay rendered onto an image (Liberation Sans). Single-input. Stable for jpeg/png/webp; TIFF (`image_tiff`) and BMP (`image_bmp`) inputs are advertised as `planned` — dispatch returns `feature_not_available` (422) until Lambda support ships. Per ADR-0004 + I4-CONS.
         - merge: Concatenate/combine multiple files into one (images, video, audio). Multi-input. Image inputs merge into animated GIF or slideshow video; image collage/grid and PDF concatenation are not supported by the V1 Lambda.
         - archive: Bundle files into ZIP/tar.gz (all types). Multi-input.
         - convert: Change file format (all types)
@@ -10971,6 +10971,287 @@ components:
             and its presence from either source. Per ticket
             [`kybXQe2S`](https://trello.com/c/kybXQe2S).
           $ref: '#/components/schemas/ImageEncodeCapabilities'
+        capabilities:
+          type: object
+          description: |
+            Tier-scoped operation-capability matrix (the
+            [operation-capability constraint model](../operation-capabilities/operation-capabilities.json),
+            ADR-0024) — per operation type: `accepts` (media classes),
+            `produces`, `availability`, `sole_op`, and the three
+            constraint families (`excludes` / `requires` /
+            `option_conflicts`). Consumers use it to pre-validate
+            operation composition (compatibility, ordering, output
+            propagation) without hardcoding pairwise rules.
+
+            **Per-op `input` block is intentionally NOT typed here**
+            (out of scope — a separate API follow-up). Each
+            `OperationCapability` is therefore left OPEN: the runtime
+            MAY include `input` (and future capability fields) untyped,
+            and consumers MUST tolerate them.
+
+            **Optional in the wire envelope** (same incremental-mirroring
+            stance as `endpoints` / `workflow_features` /
+            `image_encode_capabilities`): the runtime
+            `GET /api/operations/schema` emits it (API ticket
+            `uneE8Yoz`); the committed sidecar MAY mirror it once the
+            generator catches up. Consumers MUST tolerate its absence
+            and its presence from either source. Per ticket
+            [`9E3oqGNK`](https://trello.com/c/9E3oqGNK).
+          additionalProperties:
+            $ref: '#/components/schemas/OperationCapability'
+        output_properties:
+          type: object
+          description: |
+            Output-format property table (`output_format` → media facts)
+            backing the capability model's forward output-propagation:
+            `hasAudioTrack` (does this format carry an audio stream) and
+            `isAnimated` (single-frame vs animated; `"maybe"` for formats
+            that can be either, e.g. GIF/WebP). Consumers use it to reason
+            about what a chained operation's output can feed downstream.
+
+            **Tier-invariant** — a fixed codec fact, not an entitlement
+            (carries no `availability`).
+
+            **Optional in the wire envelope** (same incremental-mirroring
+            stance as the sibling blocks above). Per ticket
+            [`9E3oqGNK`](https://trello.com/c/9E3oqGNK).
+          additionalProperties:
+            $ref: '#/components/schemas/OutputProperties'
+
+    OperationCapability:
+      type: object
+      description: |
+        One operation type's capability entry in the `capabilities`
+        matrix (ADR-0024 operation-capability constraint model). The
+        object is deliberately OPEN (no `additionalProperties: false`):
+        the per-op `input` block is out of scope for this typing pass
+        (a separate API follow-up) and rides through untyped, as do any
+        future capability fields. Consumers MUST tolerate extra keys.
+      properties:
+        accepts:
+          type: array
+          description: |
+            Media classes this operation accepts as input (e.g.
+            `image`, `video`, `audio`, `document`, or `*` for
+            media-agnostic). Coarse media-class tokens, not MIME types —
+            per-MIME applicability lives in `operations.*.mime_groups`.
+          items:
+            type: string
+        availability:
+          $ref: '#/components/schemas/AvailabilityValue'
+        sole_op:
+          type: boolean
+          description: |
+            True when the operation must be the only operation in its job
+            (bypasses chain validation; ADR-0025). False/absent ⇒ chainable.
+        produces:
+          $ref: '#/components/schemas/CapabilityProduces'
+        excludes:
+          type: array
+          description: |
+            Hard-incompatibility constraints — when the `when` condition
+            holds the operation/option combination is rejected with the
+            constraint's `wire_code`.
+          items:
+            $ref: '#/components/schemas/CapabilityConstraint'
+        requires:
+          type: array
+          description: |
+            Co-requirement constraints — when `when` holds, the
+            `requires_field` MUST be present (else `wire_code`,
+            typically `invalid_options`).
+          items:
+            $ref: '#/components/schemas/CapabilityConstraint'
+        option_conflicts:
+          type: array
+          description: |
+            Mutually-exclusive option constraints within the operation.
+          items:
+            $ref: '#/components/schemas/CapabilityConstraint'
+
+    CapabilityProduces:
+      description: |
+        How an operation derives its output media type, for forward
+        output-propagation through a chain. Exactly one form:
+        - `same_as_input: true` — output mirrors the input format
+          (e.g. watermark, passthrough).
+        - `from_option: <option>` — output format is taken from the
+          named option's resolved value (e.g. `output_format`,
+          `output_type`, `format`).
+        - `fixed: <format>` — output is always this concrete format
+          (e.g. `audio_to_video` always produces `mp4`).
+      oneOf:
+        - type: object
+          additionalProperties: false
+          required: [same_as_input]
+          properties:
+            same_as_input:
+              type: boolean
+              enum: [true]
+        - type: object
+          additionalProperties: false
+          required: [from_option]
+          properties:
+            from_option:
+              type: string
+        - type: object
+          additionalProperties: false
+          required: [fixed]
+          properties:
+            fixed:
+              type: string
+
+    CapabilityConstraint:
+      type: object
+      description: |
+        A single capability constraint (member of `excludes` /
+        `requires` / `option_conflicts`). The `when` condition is
+        evaluated against the resolved operation + sibling-operation
+        context; when it holds, the constraint fires.
+      required:
+        - constraint_id
+        - message
+        - wire_code
+        - when
+      properties:
+        constraint_id:
+          type: string
+          description: Stable identifier for the constraint (for logs / docs / tests).
+        message:
+          type: string
+          description: |
+            Human-readable rejection message. MAY contain `{placeholder}`
+            tokens (e.g. `{output_format}`) the API interpolates at
+            evaluation time.
+        wire_code:
+          type: string
+          description: |
+            Error code emitted when the constraint fires. Aligns with the
+            error envelope `error_code` vocabulary.
+          enum:
+            - feature_not_available
+            - invalid_options
+            - INVALID_OPERATION_ORDER
+            - OPERATION_NOT_VALID_FOR_OUTPUT
+        when:
+          $ref: '#/components/schemas/CapabilityCondition'
+        availability:
+          $ref: '#/components/schemas/AvailabilityValue'
+        eval_scope:
+          type: string
+          description: |
+            Where the constraint is evaluated. `api` marks constraints the
+            API create-path enforces (vs purely-advisory ones consumers
+            mirror for UX). Absent ⇒ unscoped/advisory.
+          enum: [api]
+        requires_field:
+          type: string
+          description: |
+            Only on `requires` constraints — the field path that must be
+            present when `when` holds (e.g. `compress.target_size_bytes`).
+
+    CapabilityCondition:
+      description: |
+        Recursive condition node (the `Cond` field-token model, ADR-0024
+        §2). Exactly ONE form per node — a boolean combinator (`all` /
+        `any` / `not`) OR a single leaf test. A leaf tests one `field`
+        token with exactly one operator (`equals` / `in` / `isSet`),
+        except `opSelected` which is a standalone leaf asserting a
+        sibling operation of that type is present in the job. Consumers
+        compute field tokens locally from the resolved request (no new
+        wire field). Modelled as a `oneOf` of the valid forms (each
+        `additionalProperties: false`) so the grammar is enforced rather
+        than advertised as a loose bag of optional keys.
+      oneOf:
+        - type: object
+          additionalProperties: false
+          required: [all]
+          properties:
+            all:
+              type: array
+              description: All sub-conditions must hold (logical AND).
+              items:
+                $ref: '#/components/schemas/CapabilityCondition'
+        - type: object
+          additionalProperties: false
+          required: [any]
+          properties:
+            any:
+              type: array
+              description: At least one sub-condition must hold (logical OR).
+              items:
+                $ref: '#/components/schemas/CapabilityCondition'
+        - type: object
+          additionalProperties: false
+          required: [not]
+          properties:
+            not:
+              $ref: '#/components/schemas/CapabilityCondition'
+        - type: object
+          additionalProperties: false
+          required: [field, equals]
+          properties:
+            field:
+              type: string
+              description: Field token under test (e.g. `output_format`, `compress.encoding_mode`).
+            equals:
+              description: Leaf test — `field` equals this value (string or boolean).
+        - type: object
+          additionalProperties: false
+          required: [field, in]
+          properties:
+            field:
+              type: string
+              description: Field token under test.
+            in:
+              type: array
+              description: Leaf test — `field` is one of these values.
+              items: {}
+        - type: object
+          additionalProperties: false
+          required: [field, isSet]
+          properties:
+            field:
+              type: string
+              description: Field token under test.
+            isSet:
+              type: boolean
+              enum: [true]
+              description: |
+                Leaf test — asserts `field` is present/set. Only the
+                positive form is used; negate via a wrapping `not` node.
+        - type: object
+          additionalProperties: false
+          required: [opSelected]
+          properties:
+            opSelected:
+              type: string
+              description: |
+                Standalone leaf — true when a sibling operation of this
+                type is selected in the same job (e.g. `compress`,
+                `convert`).
+
+    OutputProperties:
+      type: object
+      description: |
+        Media facts for one output format, backing forward
+        output-propagation in the capability model.
+      required:
+        - hasAudioTrack
+        - isAnimated
+      properties:
+        hasAudioTrack:
+          type: boolean
+          description: Whether this format carries an audio stream.
+        isAnimated:
+          description: |
+            Whether output of this format is animated. `true` / `false`
+            for formats that are always one or the other; `"maybe"` for
+            formats that can be either (e.g. GIF, WebP).
+          oneOf:
+            - type: boolean
+            - type: string
+              enum: [maybe]
 
     EndpointProjection:
       type: object

package/operation-capabilities/operation-capabilities.json

@@ -515,5 +515,5 @@
       "isAnimated": "maybe"
     }
   },
-  "schema_version": "2.117.0"
+  "schema_version": "2.124.0"
 }

package/operations/schemas/archive.yaml

@@ -27,4 +27,4 @@ operation:
         # is advertised-ahead `planned` (returns feature_not_available) until the
         # worker implements per-source subfoldering. Honesty pass 2026-06-20.
         by_job: { availability: planned }
-      description: "flat = all files together at the top level (default); by_job = a separate subfolder for each source (planned — not yet honored by the worker)"
+      description: "flat = all files together at the top level (default); by_job = a separate subfolder for each source (planned — not yet supported)"

package/operations/schemas/audio_overlay.yaml

@@ -15,12 +15,12 @@ operation:
     operation (planned per ticket I20).
 
     Multi-input (Path B with `role: base` + `role: overlay` per
-    `JobInputV2.role`). `min_inputs: 2 = max_inputs: 2` for V2.0;
+    the input role). `min_inputs: 2 = max_inputs: 2` for V2.0;
     multi-overlay support is advertised as a planned feature
-    (`features.multi_overlay_stack`) but Lambda-side implementation
+    (`features.multi_overlay_stack`) but Backend implementation
     deferred.
 
-    Each input is a `MultiInputSource` — imported externally,
+    Each input is imported externally,
     referenced from a vault connection, or an upstream `job_output`
     (uploads are NOT referenced directly inside inputs[]). An uploaded
     overlay or base enters via a `passthrough` source job referenced by
@@ -31,9 +31,7 @@ operation:
     the video's audio track and the visual track passes through
     untouched.
 
-    Per ADR-0001 §1.3 (Tension 1 — `planned` operations return
-    `feature_not_available` 422 until Lambda support ships). Per
-    ADR-0004 §"V2 JobDefinition" + plan v5 §F1 round 6.
+    `planned` — not yet supported.
   default: false
   input_model: multi
   sole_op: true   # bypasses V1 chain validation — must be the only operation in its job (ADR-0025)
@@ -58,9 +56,9 @@ operation:
       description: |
         Allow up to 8 overlay inputs per job (currently capped at 1
         overlay). Per-overlay placement via
-        `JobInputV2.per_input_options`. Lambda-side support not yet
-        confirmed; tagged `planned` per ADR-0001 §1.4. Mirrors the
-        same-named feature on `image_watermark`.
+        per-input placement options. Backend support not yet
+        confirmed; tagged `planned`. Mirrors the same-named feature on
+        `image_watermark`.
 
     sync_to_silence:
       availability: planned
@@ -71,7 +69,7 @@ operation:
         silence detection runs at workflow-create time; the actual
         overlay start position is reported on
         `OperationMetrics.overlay_anchor_ms`. Gates two extra
-        options: `silence_threshold_db` and `min_silence_ms`. Lambda
+        options: `silence_threshold_db` and `min_silence_ms`. backend
         support not yet shipped.
 
   mime_groups:
@@ -400,7 +398,7 @@ operation:
             - `create_silent`: synthesise a silent base track at the
               video's framerate and mix the overlay into that.
             - `replace`: same as `create_silent` but signals intent
-              ("the overlay IS the audio track"), letting Lambda
+              ("the overlay IS the audio track"), letting backend
               skip the base-track synthesis when the overlay covers
               the full video duration.
 

package/operations/schemas/audio_to_video.yaml

@@ -14,9 +14,7 @@ operation:
     OPTIONAL `overlay` (still image, 0..1). When `overlay` is
     omitted, the video uses a solid `background_color`. The
     machine-readable cardinality lives in `per_role_cardinality`
-    on this schema (per ADR-0015). API consumption site:
-    `OperationInputRoleValidator` (rule table) consumed by
-    `SchemaValidationService.php` in `compression_api`.
+    on this schema.
 
     **Input vs output asymmetry.** The single `mime_groups.audio`
     block keys the INPUT MIME family (the `base` role input is
@@ -25,15 +23,13 @@ operation:
     the `audio_overlay.video` group pattern (input-keyed).
 
     Re-encode required (audio → video composition always re-encodes).
-    Lower framerate + FFmpeg `-tune stillimage` keeps file size
-    tiny when the overlay is a still image (the common case).
+    A lower framerate plus still-image tuning keeps file size tiny
+    when the overlay is a still image (the common case).
 
-    Per ticket [`SlluxMBN`](https://trello.com/c/SlluxMBN) +
-    ADR-0015. Activated to `availability: beta` (Wave A, ticket
-    [`c3uthIP4`](https://trello.com/c/c3uthIP4)): the cross-repo
-    Lambda backend is live (API accepts + publishes), so this is
-    shape-stable + opt-in for callers and MUST NOT return
-    `feature_not_available` — it may still change with notice while beta.
+    Activated to `availability: beta`: the backend is live (API
+    accepts + publishes), so this is shape-stable + opt-in for callers
+    and MUST NOT return `feature_not_available` — it may still change
+    with notice while beta.
 
   default: false
   input_model: multi

package/operations/schemas/audio_watermark.yaml

@@ -27,11 +27,7 @@ operation:
     + audited; the decoder will refuse to extract from media the
     caller did not mark themselves) — pin per spike S11 acceptance.
 
-    Per ADR-0001 §1.3 (Tension 1 — `planned` operations return
-    `feature_not_available` 422 until Lambda support ships).
-    Per plan v5 §F1 round 6 (codex narrowed methods enum from 5 to 3,
-    dropping `spread_spectrum` / `echo_hiding` / `phase_coding` —
-    textbook families, not product choices).
+    `planned` — not yet supported.
   default: false
   input_model: single