docs: add how-to for transferring Helm charts with OCM (#751)

#### What this PR does / why we need it

Adds a how-to guide for transferring component versions containing Helm
chart resources (`helm/v1` access type) between OCI registries using the
OCM CLI. Covers the `--upload-as localBlob` and `--upload-as
ociArtifact` options.

Related to
open-component-model/open-component-model#1846

#### Which issue(s) this PR is related to

Related to
open-component-model/open-component-model#1846 (comment)

#### Type of content

- [ ] Tutorial (`getting-started/` or `tutorials/`)
- [x] How-to Guide (`how-to/`)
- [ ] Explanation / Concept (`concepts/`)
- [ ] Reference (`reference/`)
- [ ] Other (infrastructure, config, fixes)

#### Checklist

- [x] I have read and followed the [Contributing
Guide](https://github.com/open-component-model/ocm-website/blob/main/CONTRIBUTING.md)
- [x] All commands/code snippets are tested and can be copy-pasted


#### Test

```bash
#!/bin/zsh

set -e

REGISTRY="${REGISTRY:-ghcr.io/matthiasbruns/ocm-tutorials}"
COMPONENT="ocm.software/podinfo"
VERSION="6.9.1"

CTF_DIR=$(mktemp -d)
echo "CTF archive: $CTF_DIR"

pause() {
  echo "\n>>> Next: $1"
  echo "--- Press Enter to continue ---"
  read
}

# Step 1: Create constructor.yaml
cat <<EOF > constructor.yaml
components:
- name: ${COMPONENT}
  version: ${VERSION}
  provider:
    name: ocm.software
  resources:
  - name: podinfo
    version: ${VERSION}
    type: helmChart
    access:
      type: helm/v1
      helmRepository: https://stefanprodan.github.io/podinfo
      helmChart: podinfo-${VERSION}.tgz
EOF

echo "Created constructor.yaml"

pause "Add component version to CTF archive"

# Step 2: Add component version to CTF
./ocm add cv \
  --repository "ctf::${CTF_DIR}" \
  --constructor constructor.yaml \
  --skip-reference-digest-processing

echo "Component version added to CTF"

pause "Transfer with --upload-as ociArtifact"

# Step 3: Transfer as ociArtifact
./ocm transfer cv \
  --copy-resources \
  --upload-as ociArtifact \
  "ctf::${CTF_DIR}//${COMPONENT}:${VERSION}" \
  "${REGISTRY}"

echo "Transfer complete (ociArtifact)"

pause "Verify: get component version from registry"

# Step 4: Verify component version
./ocm get cv "${REGISTRY}//${COMPONENT}:${VERSION}"

pause "Verify: inspect component descriptor to find imageReference"

# Step 5: Inspect component descriptor to find imageReference
./ocm get cv "${REGISTRY}//${COMPONENT}:${VERSION}" -o yaml

pause "Verify: download the chart resource"

# Step 6: Download the chart resource
rm -rf ./downloaded
./ocm download resource \
  "${REGISTRY}//${COMPONENT}:${VERSION}" \
  --identity "name=podinfo,version=${VERSION}" \
  --output ./downloaded

echo "\nDownloaded to ./downloaded:"
ls -la ./downloaded

# Cleanup
pause "Clean up CTF archive"
rm -rf "${CTF_DIR}"
echo "Removed ${CTF_DIR}"
echo "\nDone."

```

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Documentation**
* Added a detailed how-to for transferring Helm-chart-backed component
versions between OCI registries via the CLI, including prerequisites,
step-by-step workflow, verification, storage modes, cross-registry
examples, and relevant commands.

* **Chores**
* Expanded repository configuration wordlist with two additional entries
to recognize more terms.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: Matthias Bruns <git@matthiasbruns.com>

Author: matthiasbruns

.github/config/wordlist.txt

@@ -465,3 +465,5 @@ hasmermaid
 XDG
 subpaths
 IAM
+pullable
+descriptor's

content/docs/how-to/transfer-helm-charts.md

@@ -0,0 +1,168 @@
+---
+title: "Transfer Helm Charts with OCM"
+description: "Transfer component versions containing Helm chart resources between OCI registries using the OCM CLI."
+weight: 110
+toc: true
+---
+
+## Goal
+
+Transfer a component version that contains a Helm chart resource sourced from a **Helm repository** (type `helmChart` with `helm/v1` access)
+to an OCI registry. This guide does not cover charts that are already stored as OCI artifacts.
+
+## Prerequisites
+
+- [OCM CLI]({{< relref "docs/getting-started/ocm-cli-installation.md" >}}) installed
+- Write access to a target OCI registry with [credentials configured]({{< relref "docs/how-to/configure-multiple-credentials.md" >}})
+- A component version containing a Helm chart resource (stored in a CTF archive or OCI registry)
+
+## Steps
+
+{{< steps >}}
+
+{{<callout context="note" title="Helm charts stored as ociImage" icon="outline/info-circle">}}
+If your existing component version contains a Helm chart stored as an `ociImage` resource rather than a `helmChart` with `helm/v1` access, you need to
+create a new component version using the `helmChart` type as shown below. This guide only covers the transfer of Helm charts sourced from Helm
+repositories.
+{{< /callout >}}
+
+{{< step >}}
+
+### Create a component version with a Helm chart resource
+
+If you already have a component version containing a Helm chart with `helm/v1` access, skip to the next step.
+
+Create a `constructor.yaml` that references a chart from a Helm repository:
+
+```yaml
+components:
+  - name: example.com/my-app
+    version: 1.0.0
+    provider:
+      name: example.com
+    resources:
+      - name: my-chart
+        version: 1.0.0
+        type: helmChart
+        access:
+          type: helm/v1
+          helmRepository: https://charts.example.com
+          helmChart: my-chart-1.0.0.tgz
+```
+
+Add the component version to a CTF archive:
+
+```bash
+ocm add cv --repository ctf::<path/to/archive> \
+  --constructor constructor.yaml \
+  --skip-reference-digest-processing
+```
+
+{{< /step >}}
+
+{{<callout context="caution" title="Why --skip-reference-digest-processing?" icon="outline/alert-triangle">}}
+The `--skip-reference-digest-processing` flag is required because the `helm/v1` access type currently cannot be fully resolved during `add cv`.
+The chart is not downloaded at this stage, so digest calculation is not possible. The digests are computed later during transfer when the chart is
+actually fetched.
+Full Helm support is being tracked as a future feature in [ocm-project#911](https://github.com/open-component-model/ocm-project/issues/911).
+{{< /callout >}}
+
+{{< step >}}
+
+### Transfer the component version
+
+Transfer the component version to the target registry. Use `--copy-resources` to include the Helm chart and `--upload-as ociArtifact` to store it as a
+standalone OCI artifact in the target registry.
+
+> **Note:** The `--upload-as` flag is a temporary solution. It will be superseded by the upcoming transfer specification.
+> See [ocm-project#925](https://github.com/open-component-model/ocm-project/issues/925) for details.
+
+```bash
+ocm transfer cv \
+  --copy-resources \
+  --upload-as ociArtifact \
+  ctf::<path/to/archive>//<component-name>:<version> \
+  <target-registry>
+```
+
+During transfer, the Helm chart is always converted to an OCI artifact. With `--upload-as ociArtifact`,
+this artifact is uploaded as a separate image in the target registry.
+The component descriptor references it via an `imageReference` (e.g., `ghcr.io/my-org/charts/my-chart:1.0.0`),
+making it independently addressable and pullable with `helm pull`. For more details on how transfers and resource handling work,
+see [Transfer and Transport]({{< relref "docs/concepts/transfer-concept.md" >}}).
+
+Alternatively, `--upload-as localBlob` embeds the chart directly in the component version's blob store.
+This keeps the chart coupled to the component version but means it is not independently addressable in the registry and cannot be pulled with the Helm
+CLI.
+
+To find the `imageReference`, inspect the component descriptor:
+
+```bash
+ocm get cv <target-registry>//<component-name>:<version> -o yaml
+```
+
+In the output, look for the `resources[].access.imageReference` field:
+
+```yaml
+resources:
+  - name: my-chart
+    type: helmChart
+    access:
+      type: ociArtifact/v1
+      imageReference: ghcr.io/my-org/charts/my-chart:1.0.0
+```
+
+Use the `imageReference` value with Helm's OCI support:
+
+```bash
+helm pull oci://ghcr.io/my-org/charts/my-chart --version 1.0.0
+```
+
+{{< /step >}}
+{{< step >}}
+
+### Verify the transfer
+
+Confirm the component version is available in the target registry:
+
+```bash
+ocm get cv <target-registry>//<component-name>:<version>
+```
+
+Download the chart resource to verify it was transferred correctly:
+
+```bash
+ocm download resource \
+  <target-registry>//<component-name>:<version> \
+  --identity name=my-chart \
+  --output ./downloaded
+```
+
+{{< /step >}}
+{{< /steps >}}
+
+## Transfer between registries
+
+To transfer a Helm chart component version from one OCI registry to another, use the source registry reference directly:
+
+```bash
+ocm transfer cv \
+  --copy-resources \
+  --upload-as ociArtifact \
+  <source-registry>//<component-name>:<version> \
+  <target-registry>
+```
+
+## Tips
+
+- **If provenance files (`.prov`) are present** in the Helm repository, they are automatically included in the transfer.
+- **If you need to transfer recursively**, add `--recursive` to include all transitively referenced component versions.
+- **For air-gapped environments**, first transfer to a CTF archive, move it across the boundary, then import into the target registry.
+  See [Transfer Components Across an Air Gap]({{< relref "docs/how-to/air-gap-transfer.md" >}}).
+
+## Related documentation
+
+- [Transfer and Transport]({{< relref "docs/concepts/transfer-concept.md" >}}) -- Understand the transfer model and resource handling
+- [Transfer Components Across an Air Gap]({{< relref "docs/how-to/air-gap-transfer.md" >}}) -- Air-gapped transfer workflows
+- [Download Resources from Component Versions]({{< relref "docs/how-to/download-resources-from-component-versions.md" >}}) -- Download individual
+  resources