How do I safely work with sanitized parameters without aliasing?

  someFunc(input as sanitized String)
    alias <- input       // BOTH point to same memory!

  pureProcess() as pure
    -> input as sanitized String
    localCopy <- String(input)    // Creates NEW independent copy

  nonPureProcess()
    -> input as sanitized String
    safeCopy <- String(input)     // Option 1: copy constructor
    target: ""
    target :=: safeCopy           // Option 2: copy operator on initialized var

  directUse() as pure
    -> input as sanitized String
    result: "Output: " + input    // OK: concatenation creates new value

defines module qa.sanitizeddeep.safecopy

  defines function

    <?-
      Pure context: copy constructor is the ONLY safe option.
      Direct assignment would create hidden alias to sanitized copy.
    -?>
    pureExtract() as pure
      -> rawInput as sanitized String
      <- cleaned as String: ""

      safeCopy <- String(rawInput)
      cleaned: safeCopy

    <?-
      Direct expression use works without assignment.
      String concatenation creates a new value, not an alias.
    -?>
    formatMessage() as pure
      -> userMessage as sanitized String
      <- formatted as String: ""

      formatted: "Message: " + userMessage

    <?-
      Non-pure context: copy constructor works here too.
      This is the universal safe pattern.
    -?>
    logAndProcess()
      -> inputData as sanitized String
      <- processed as String: ""

      localCopy <- String(inputData)
      processed: localCopy

    <?-
      Passing sanitized parameter to another function is always safe.
      The receiving function gets the sanitized copy, no alias created.
    -?>
    delegateWork()
      -> externalInput as sanitized String
      <- result as String: ""

      result: formatMessage(externalInput)

  defines program

    SafeCopyDemo()
      stdout <- Stdout()

      cleanResult <- pureExtract("user data")
      stdout.println(`Pure extract: ${cleanResult}`)

      formatted <- formatMessage("hello world")
      stdout.println(formatted)

      logged <- logAndProcess("log entry")
      stdout.println(`Logged: ${logged}`)

      delegated <- delegateWork("delegated input")
      stdout.println(delegated)

safeCopy <- rawInput

safeCopy <- String(rawInput)