Description
Ensure caller prefix and suffix are present after stripping/reapplying at most one matching affix; repeated inner affixes remain literal data, no recursive stripping or path semantics.
An opaque key’s representation can affect equality and ordering even when its underlying value is unchanged. Delimiter joining can be ambiguous, fixed-width padding can preserve numeric order within agreed bounds, and typed length-prefix framing keeps scalar types distinct. Lengths in this family count UTF-16 code units unless a different unit is stated.
Ensure caller prefix and suffix are present after stripping/reapplying at most one matching affix; repeated inner affixes remain literal data, no recursive stripping or path semantics.
When to use this tool
Use this tool to ensure caller prefix and suffix are present after stripping/reapplying at most one matching affix; repeated inner affixes remain literal data, no recursive stripping or path semantics.
How to use the tool and how it works
- Enter keys, prefix, suffix using the field definitions below.
- Run the operation. Correct input errors before interpreting an output.
- Read result.keys. Use the ordering, boundary rules and absence conditions described below.
Remove one matching prefix and one matching suffix from each key when present, then reattach the supplied prefix and suffix.1
| Input field | Meaning and units | Accepted input |
|---|---|---|
| keys | Opaque key strings in original order. | Dense list of at most 128 strings, each at most 8,192 UTF-16 code units. |
| prefix | Desired prefix; may be empty. | Text, at most 8,192 UTF-16 code units; the operation’s grammar also applies. |
| suffix | Desired suffix; may be empty. | Text, at most 8,192 UTF-16 code units; the operation’s grammar also applies. |
| Output field | Interpretation |
|---|---|
| result | Object containing the named fields below. |
| result.keys | Transformed opaque key strings in original order. |
{
"input": {
"keys": [
"a",
"pre-a-end"
],
"prefix": "pre-",
"suffix": "-end"
},
"output": {
"result": {
"keys": [
"pre-a-end",
"pre-a-end"
]
}
}
}Limitations and assumptions
- Only one occurrence of each affix is removed; the operation may collapse different original spellings.
- String framing and alphabet digits use UTF-16 code units, not bytes or grapheme clusters. Exact integer text accepts a signed decimal spelling of at most 256 digits before operation-specific range checks.
- Every declared top-level input field is required and unexpected fields are rejected. Ordinary strings are limited to 8,192 UTF-16 code units and lists to 128 entries, with tighter operation-specific bounds where stated. JSON text has bounded nesting and node counts.
- Numeric outputs must be finite and no larger in absolute magnitude than the safe-integer limit; operations returning exact large integers use decimal text. Positions are zero-based and spans end exclusively unless the operation explicitly states a different convention.
Alternative or Complementary methods
Use typed framing when distinct scalar types or tuple boundaries must remain distinguishable. Keep alphabet, width, normalization and numeric bounds consistent between producers and consumers.
References
Similar or alternative tools
- Opaque Key Alphabet Audit
Audit opaque key UTF-16 code units against an explicit caller alphabet with positions; not Unicode grapheme, entropy or checksum validation.
- Opaque Key Delimiter Ambiguity Audit
Audit literal delimiter occurrences and empty components before naive opaque composite-key joining; reports hazards without inventing an escaping dialect.