diff --git a/content/master/cli/command-reference.md b/content/master/cli/command-reference.md
index 932d5865..6fca3d5a 100644
--- a/content/master/cli/command-reference.md
+++ b/content/master/cli/command-reference.md
@@ -32,6 +32,135 @@ Client Version: v1.16.0
 Server Version: v1.16.0
 ```
 
+## render 
+
+The `crossplane render` command previews the output of a 
+[composite resource]({{<ref "../concepts/composite-resources">}}) after applying 
+any [composition functions]({{<ref "../concepts/compositions">}}).
+
+{{< hint "important" >}}
+The `crossplane render` requires you to use composition functions.
+{{< /hint >}}
+
+The `crossplane render` command connects to the locally running Docker 
+Engine to pull and run composition functions. 
+
+{{<hint "important">}} 
+Running `crossplane render` requires [Docker](https://www.docker.com/).
+{{< /hint >}}
+
+Provide a composite resource, composition and composition function YAML 
+definition with the command to render the output locally. 
+
+For example, 
+`crossplane render xr.yaml composition.yaml function.yaml`
+
+The output includes the original composite resource followed by the generated 
+managed resources. 
+
+{{<expand "An example render output" >}}
+```yaml
+---
+apiVersion: nopexample.org/v1
+kind: XBucket
+metadata:
+  name: test-xrender
+status:
+  bucketRegion: us-east-2
+---
+apiVersion: s3.aws.upbound.io/v1beta1
+kind: Bucket
+metadata:
+  annotations:
+    crossplane.io/composition-resource-name: my-bucket
+  generateName: test-xrender-
+  labels:
+    crossplane.io/composite: test-xrender
+  ownerReferences:
+  - apiVersion: nopexample.org/v1
+    blockOwnerDeletion: true
+    controller: true
+    kind: XBucket
+    name: test-xrender
+    uid: ""
+spec:
+  forProvider:
+    region: us-east-2
+```
+{{< /expand >}}
+
+### Flags
+
+{{< table "table table-sm table-striped">}}
+| Short flag   | Long flag                             | Description                                           |
+| ------------ | -------------                         | ------------------------------                        |
+|              | `--context-files=<key>=<file>,<key>=<file>`    | A comma separated list of files to load for function "contexts." |
+|              | `--context-values=<key>=<value>,<key>=<value>` | A comma separated list of key-value pairs to load for function "contexts."                                                    |
+| `-r`         | `--include-function-results`          | Include the "results" or events from the function.   |
+| `-o`         | `--observed-resources=<directory or file>`               |
+Provide artificial managed resource data to the function.
+|
+| `-x`         | `--include-full-xr`          | Include a copy of the input Composite Resource spec and metadata fields in the rendered output.   |
+|              | `--timeout=`                          | Amount of time to wait for a function to finish.                    |
+{{< /table >}}
+
+The `crossplane render` command relies on standard 
+[Docker environmental variables](https://docs.docker.com/engine/reference/commandline/cli/#environment-variables) 
+to connect to the local Docker engine and run composition functions. 
+
+
+### Provide function context
+
+The `--context-files` and `--context-values` flags can provide data 
+to a function's `context`.  
+The context is JSON formatted data.
+
+### Include function results
+
+If a function produces Kubernetes events with statuses use the 
+`--include-function-results` to print them along with the managed resource 
+outputs. 
+
+### Include the composite resource 
+
+Composition functions can only change the `status` field of a composite 
+resource. By default, the `crossplane render` command only prints the
+`status` field with `metadata.name`.  
+
+Use `--include-full-xr` to print the full composite resource, 
+including the `spec` and `metadata` fields.
+
+### Mock managed resources
+
+Provide mocked, or artificial data representing a managed resource with 
+`--observed-resources`. The `crossplane render` command treats the 
+provided inputs as if they were resources in a Crossplane cluster. 
+
+A function can reference and manipulate the included resource as part of 
+running the function.
+
+The `observed-resources` may be a single YAML file with multiple resources or a 
+directory of YAML files representing multiple resources.
+
+Inside the YAML file include an 
+{{<hover label="apiVersion" line="1">}}apiVersion{{</hover>}},
+{{<hover label="apiVersion" line="2">}}kind{{</hover>}},
+{{<hover label="apiVersion" line="3">}}metadata{{</hover>}} and
+{{<hover label="apiVersion" line="7">}}spec{{</hover>}}.
+
+```yaml {label="apiVersion"}
+apiVersion: example.org/v1alpha1
+kind: ComposedResource
+metadata:
+  name: test-render-b
+  annotations:
+    crossplane.io/composition-resource-name: resource-b
+spec:
+  coolerField: "I'm cooler!"
+```
+
+The schema of the resource isn't validated and may contain any data.
+
 ## xpkg
 
 The `crossplane xpkg` commands create, install and update Crossplane
@@ -51,7 +180,7 @@ The CLI applies the required annotations and values to meet the
 
 The `crossplane` CLI supports building 
 [configuration]({{< ref "../concepts/packages" >}}),
-[function]({{<ref "../concepts/composition-functions">}}) and 
+[function]({{<ref "../concepts/compositions">}}) and 
 [provider]({{<ref "../concepts/providers" >}}) package types. 
 
 
@@ -117,6 +246,52 @@ Use `docker pull` to download a missing image.
 The `--embed-runtime-image-tarball` flag includes a local OCI image tarball 
 inside the function or provider package.
 
+### xpkg init
+
+The `crossplane xpkg init` command populates the current directory with 
+files to build a package. 
+
+Provide a name to use for the package and the package template to start from 
+with the command  
+`crossplane xpkg init <name> <template>`
+
+The `<name>` input isn't used. Crossplane reserves the `<name>` for future releases.
+
+The `<template>` value may be one of four well known templates:
+* `configuration-template` - A template to build a Crossplane [Configuration]({{<ref "../concepts/packages">}}) from the [crossplane/configuration-template](https://github.com/crossplane/configuration-template) repository.
+* `function-template-go` - A template to build Crossplane Go [composition functions]({{<ref "../concepts/compositions">}}) from the [crossplane/function-template-go](https://github.com/crossplane/function-template-go) repository.
+* `function-template-python` - A template to build Crossplane Python [composition functions]({{<ref "../concepts/compositions">}}) from the [crossplane/function-template-python](https://github.com/crossplane/function-template-go) repository.
+* `provider-template` - A template to build a basic Crossplane provider from the [Crossplane/provider-template](https://github.com/crossplane/provider-template) repository.
+* `provider-template-upjet` - A template for building [Upjet](https://github.com/crossplane/upjet) based Crossplane providers from existing Terraform providers. Copies from the [upbound/upjet-provider-template](https://github.com/upbound/upjet-provider-template) repository.
+
+Instead of a well known template the `<template>` value can be a git repository 
+URL.
+
+#### NOTES.txt
+
+If the template repository contains a `NOTES.txt` file in its root directory,
+the `crossplane xpkg init` command prints the contents of the file to the
+terminal after populating the directory with the template files. This can be
+useful for providing information about the template.
+
+#### init.sh
+
+If the template repository contains an `init.sh` file in its root directory, the
+`crossplane xpkg init` command starts a dialog after populating the
+directory with the template files. The dialog prompts the user if they want
+to view or run the script. Use the initialization script to automatically
+personalize the template.
+
+#### Flags
+{{< table "table table-sm table-striped">}}
+| Short flag   | Long flag               | Description                                                                                      |
+| ------------ | ----------------------- | ------------------------------                                                                   |
+| `-b`         | `--ref-name`            | The branch or tag to clone from the template repository.                                         |
+| `-d`         | `--directory`           | The directory to create and load the template files into. Uses the current directory by default. |
+| `-r`         | `--run-init-script`     | Run the init.sh script without prompting, if it exists.                                                        |
+<!-- vale Crossplane.Spelling = YES -->
+{{< /table >}}
+
 
 ### xpkg install
 
@@ -341,9 +516,8 @@ converts a Crossplane resource to a new version or kind.
 Use the `crossplane beta convert` command to convert an existing
 [ControllerConfig]({{<ref "../concepts/providers#controller-configuration">}})
 to a [DeploymentRuntimeConfig]({{<ref "../concepts/providers#runtime-configuration">}}) 
-or a Composition using [patch and transforms]({{<ref "../concepts/patch-and-transform">}}) 
-to a 
-[Composition pipeline function]({{< ref "../concepts/compositions#use-composition-functions" >}}).
+or a legacy Composition using `mode: Resources` to a 
+[Composition pipeline function]({{< ref "../concepts/compositions" >}}).
 
 Provide the `crossplane beta convert` command the conversion type, the input
 file and optionally, an output file. By default the command writes the output to
@@ -373,138 +547,6 @@ By default the function name is "function-patch-and-transform."
 {{< /table >}}
 
 
-### beta render 
-
-The `crossplane beta render` command previews the output of a 
-[composite resource]({{<ref "../concepts/composite-resources">}}) after applying 
-any [composition functions]({{<ref "../concepts/composition-functions">}}).
-
-{{< hint "important" >}}
-The `crossplane beta render` command doesn't apply 
-[patch and transform composition patches]({{<ref "../concepts/patch-and-transform">}}).
-
-The command only supports function "patch and transforms."
-{{< /hint >}}
-
-The `crossplane beta render` command connects to the locally running Docker 
-Engine to pull and run composition functions. 
-
-{{<hint "important">}} 
-Running `crossplane beta render` requires [Docker](https://www.docker.com/).
-{{< /hint >}}
-
-Provide a composite resource, composition and composition function YAML 
-definition with the command to render the output locally. 
-
-For example, 
-`crossplane beta render xr.yaml composition.yaml function.yaml`
-
-The output includes the original composite resource followed by the generated 
-managed resources. 
-
-{{<expand "An example render output" >}}
-```yaml
----
-apiVersion: nopexample.org/v1
-kind: XBucket
-metadata:
-  name: test-xrender
-status:
-  bucketRegion: us-east-2
----
-apiVersion: s3.aws.upbound.io/v1beta1
-kind: Bucket
-metadata:
-  annotations:
-    crossplane.io/composition-resource-name: my-bucket
-  generateName: test-xrender-
-  labels:
-    crossplane.io/composite: test-xrender
-  ownerReferences:
-  - apiVersion: nopexample.org/v1
-    blockOwnerDeletion: true
-    controller: true
-    kind: XBucket
-    name: test-xrender
-    uid: ""
-spec:
-  forProvider:
-    region: us-east-2
-```
-{{< /expand >}}
-
-#### Flags
-
-{{< table "table table-sm table-striped">}}
-| Short flag   | Long flag                             | Description                                           |
-| ------------ | -------------                         | ------------------------------                        |
-|              | `--context-files=<key>=<file>,<key>=<file>`    | A comma separated list of files to load for function "contexts." |
-|              | `--context-values=<key>=<value>,<key>=<value>` | A comma separated list of key-value pairs to load for function "contexts."                                                    |
-| `-r`         | `--include-function-results`          | Include the "results" or events from the function.   |
-| `-o`         | `--observed-resources=<directory or file>`               |
-Provide artificial managed resource data to the function.
-|
-| `-x`         | `--include-full-xr`          | Include a copy of the input Composite Resource spec and metadata fields in the rendered output.   |
-|              | `--timeout=`                          | Amount of time to wait for a function to finish.                    |
-{{< /table >}}
-
-The `crossplane beta render` command relies on standard 
-[Docker environmental variables](https://docs.docker.com/engine/reference/commandline/cli/#environment-variables) 
-to connect to the local Docker engine and run composition functions. 
-
-
-#### Provide function context
-
-The `--context-files` and `--context-values` flags can provide data 
-to a function's `context`.  
-The context is JSON formatted data.
-
-#### Include function results
-
-If a function produces Kubernetes events with statuses use the 
-`--include-function-results` to print them along with the managed resource 
-outputs. 
-
-#### Include the composite resource 
-
-Composition functions can only change the `status` field of a composite 
-resource. By default, the `crossplane beta render` command only prints the
-`status` field with `metadata.name`.  
-
-Use `--include-full-xr` to print the full composite resource, 
-including the `spec` and `metadata` fields.
-
-#### Mock managed resources
-
-Provide mocked, or artificial data representing a managed resource with 
-`--observed-resources`. The `crossplane beta render` command treats the 
-provided inputs as if they were resources in a Crossplane cluster. 
-
-A function can reference and manipulate the included resource as part of 
-running the function.
-
-The `observed-resources` may be a single YAML file with multiple resources or a 
-directory of YAML files representing multiple resources.
-
-Inside the YAML file include an 
-{{<hover label="apiVersion" line="1">}}apiVersion{{</hover>}},
-{{<hover label="apiVersion" line="2">}}kind{{</hover>}},
-{{<hover label="apiVersion" line="3">}}metadata{{</hover>}} and
-{{<hover label="apiVersion" line="7">}}spec{{</hover>}}.
-
-```yaml {label="apiVersion"}
-apiVersion: example.org/v1alpha1
-kind: ComposedResource
-metadata:
-  name: test-render-b
-  annotations:
-    crossplane.io/composition-resource-name: resource-b
-spec:
-  coolerField: "I'm cooler!"
-```
-
-The schema of the resource isn't validated and may contain any data.
-
 ### beta top
 
 The command `crossplane beta top` shows CPU and memory usage of Crossplane
@@ -837,7 +879,7 @@ scenarios:
 
 - Validate a managed resource or composite resource 
   [against a Provider or XRD schema](#validate-resources-against-a-schema). 
-- Use the output of `crossplane beta render` as [validation input](#validate-render-command-output). 
+- Use the output of `crossplane render` as [validation input](#validate-render-command-output). 
 - Validate an [XRD against Kubernetes Common Expression Language](#validate-common-expression-language-rules) 
   (CEL) rules.
 - Validate resources against a [directory of schemas](#validate-against-a-directory-of-schemas).
@@ -933,16 +975,16 @@ Total 1 resources: 0 missing schemas, 1 success case, 0 failure cases
 
 #### Validate render command output
 
-You can pipe the output of `crossplane beta render` into 
+You can pipe the output of `crossplane render` into 
 `crossplane beta validate` to validate complete Crossplane resource pipelines,
 including XRs, compositions and composition functions. 
 
-Use the `--include-full-xr` command with `crossplane beta render` and the `-` 
+Use the `--include-full-xr` command with `crossplane render` and the `-` 
 option with `crossplane beta validate` to pipe the output from 
-`crossplane beta render` to the input of `crossplane beta validate`. 
+`crossplane render` to the input of `crossplane beta validate`. 
 
 ```shell {copy-lines="1"}
-crossplane beta render xr.yaml composition.yaml function.yaml --include-full-xr | crossplane beta validate schemas.yaml -
+crossplane render xr.yaml composition.yaml function.yaml --include-full-xr | crossplane beta validate schemas.yaml -
 [x] schema validation error example.crossplane.io/v1beta1, Kind=XR, example : status.conditions[0].lastTransitionTime: Invalid value: "null": status.conditions[0].lastTransitionTime in body must be of type string: "null"
 [x] schema validation error example.crossplane.io/v1beta1, Kind=XR, example : spec: Required value
 [✓] iam.aws.upbound.io/v1beta1, Kind=AccessKey, sample-access-key-0 validated successfully
@@ -1015,7 +1057,7 @@ Total 1 resources: 0 missing schemas, 0 success cases, 1 failure cases
 
 #### Validate against a directory of schemas
 
-The `crossplane beta render` command can validate a directory of YAML files. 
+The `crossplane render` command can validate a directory of YAML files. 
 
 The command only processes `.yaml` and `.yml` files, while ignoring all other
 file types.
@@ -1051,51 +1093,4 @@ crossplane beta validate schema resources.yaml
 Total 5 resources: 0 missing schemas, 4 success cases, 1 failure cases
 ```
 
-### beta xpkg init
-
-The `crossplane beta xpkg init` command populates the current directory with 
-files to build a package. 
-
-Provide a name to use for the package and the package template to start from 
-with the command  
-`crossplane beta xpkg init <name> <template>`
-
-The `<name>` input isn't used. Crossplane reserves the `<name>` for future releases.
-
-The `<template>` value may be one of four well known templates:
-* `configuration-template` - A template to build a Crossplane [Configuration]({{<ref "../concepts/packages">}}) from the [crossplane/configuration-template](https://github.com/crossplane/configuration-template) repository.
-* `function-template-go` - A template to build Crossplane Go [composition functions]({{<ref "../concepts/composition-functions">}}) from the [crossplane/function-template-go](https://github.com/crossplane/function-template-go) repository.
-* `function-template-python` - A template to build Crossplane Python [composition functions]({{<ref "../concepts/composition-functions">}}) from the [crossplane/function-template-python](https://github.com/crossplane/function-template-go) repository.
-* `provider-template` - A template to build a basic Crossplane provider from the [Crossplane/provider-template](https://github.com/crossplane/provider-template) repository.
-* `provider-template-upjet` - A template for building [Upjet](https://github.com/crossplane/upjet) based Crossplane providers from existing Terraform providers. Copies from the [upbound/upjet-provider-template](https://github.com/upbound/upjet-provider-template) repository.
-
-Instead of a well known template the `<template>` value can be a git repository 
-URL.
-
-#### NOTES.txt
-
-If the template repository contains a `NOTES.txt` file in its root directory,
-the `crossplane beta xpkg init` command prints the contents of the file to the
-terminal after populating the directory with the template files. This can be
-useful for providing information about the template.
-
-#### init.sh
-
-If the template repository contains an `init.sh` file in its root directory, the
-`crossplane beta xpkg init` command starts a dialog after populating the
-directory with the template files. The dialog prompts the user if they want
-to view or run the script. Use the initialization script to automatically
-personalize the template.
-
-#### Flags
-{{< table "table table-sm table-striped">}}
-| Short flag   | Long flag               | Description                                                                                      |
-| ------------ | ----------------------- | ------------------------------                                                                   |
-| `-b`         | `--ref-name`            | The branch or tag to clone from the template repository.                                         |
-| `-d`         | `--directory`           | The directory to create and load the template files into. Uses the current directory by default. |
-| `-r`         | `--run-init-script`     | Run the init.sh script without prompting, if it exists.                                                        |
-<!-- vale Crossplane.Spelling = YES -->
-{{< /table >}}
-
-
 
diff --git a/content/master/concepts/_index.md b/content/master/concepts/_index.md
index 3c821d9e..1407bfb6 100644
--- a/content/master/concepts/_index.md
+++ b/content/master/concepts/_index.md
@@ -55,16 +55,6 @@ building and managing external resources through Kubernetes.
   Composite Resource. Platform users create Claims in their unique namespace,
   isolating their resources from other teams in other namespaces. 
 
-* [**Composition Functions**]({{<ref "./composition-functions">}}) are custom
-  programs, written your programming language of choice, to apply logic and
-  loops before or after Crossplane creates resources. 
-
-* [**Patches and Transforms**]({{<ref "./patch-and-transform">}}) allow platform
-  engineers to use user inputs to their custom API and change how Crossplane
-  creates resources. Patches and transforms allow for flexible and
-  abstract inputs like `big` or `encrypted` to have specific meanings when
-  creating the actual managed resources.
-
 * [**EnvironmentConfigs**]({{<ref "./environment-configs">}}) are an in-memory
   data store, like a Kubernetes ConfigMap. EnvironmentConfigs are useful for
   custom resource mapping or storing and retrieving data across Claims and
diff --git a/content/master/concepts/composite-resources.md b/content/master/concepts/composite-resources.md
index 35ccd792..8d6828b8 100644
--- a/content/master/concepts/composite-resources.md
+++ b/content/master/concepts/composite-resources.md
@@ -133,16 +133,27 @@ kind: Composition
 metadata:
   name: my-composition
 spec:
-  resources:
-    - name: database
-      base:
-        # Removed for brevity
-      patches:
-      - fromFieldPath: metadata.annotations
-        toFieldPath: metadata.annotations
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: database
+        base:
+          # Removed for brevity
+        patches:
+        - fromFieldPath: metadata.annotations
+          toFieldPath: metadata.annotations
 ```
 
-For more information on patching resources refer to the [Patch and Transform]({{<ref "./patch-and-transform">}}) documentation. 
+For more information on using `function-patch-and-transform` to patch
+resources refer to the
+[Function Patch and Transform]({{<ref "../guides/function-patch-and-transform">}})
+documentation. 
 
 ### Composition selection
 
diff --git a/content/master/concepts/composition-functions.md b/content/master/concepts/composition-functions.md
deleted file mode 100644
index 59dc4366..00000000
--- a/content/master/concepts/composition-functions.md
+++ /dev/null
@@ -1,745 +0,0 @@
----
-title: Composition Functions
-state: beta
-alphaVersion: "1.11"
-betaVersion: "1.14"
-weight: 80
-description: "Composition Functions allow you to template resources using general-purpose programming languages"
-aliases: 
-  - /knowledge-base/guides/composition-functions
----
-
-Composition functions (or just functions, for short) are custom programs that
-template Crossplane resources. Crossplane calls composition functions to
-determine what resources it should create when you create a composite resource
-(XR). You can write a function to template resources using a general purpose
-programming language like Go or Python. Using a general purpose programming
-language allows a Function to use more advanced logic to template resources,
-like loops and conditionals.
-
-You can build a function using general purpose programming languages such as Go
-or Python. The Crossplane community has also built functions that let you
-template Crossplane resources using [CUE](https://cuelang.org), Helm-like
-[Go templates](https://pkg.go.dev/text/template) or
-[Patch and Transforms]({{<ref "./patch-and-transform">}}).
-
-## Install a composition function
-
-Installing a Function creates a function pod. Crossplane sends requests to this
-pod to ask it what resources to create when you create a composite resource.
-
-Install a Function with a Crossplane
-{{<hover label="install" line="2">}}Function{{</hover >}} object setting the
-{{<hover label="install" line="6">}}spec.package{{</hover >}} value to the
-location of the function package.
-
-
-For example, to install [Function Patch and Transform](https://github.com/crossplane-contrib/function-patch-and-transform),
-
-```yaml {label="install"}
-apiVersion: pkg.crossplane.io/v1beta1
-kind: Function
-metadata:
-  name: function-patch-and-transform
-spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
-```
-
-{{< hint "tip" >}}
-Functions are Crossplane Packages. Read more about Packages in the
-[Packages documentation]({{<ref "packages" >}}).
-{{< /hint >}}
-
-By default, the Function pod installs in the same namespace as Crossplane
-(`crossplane-system`).
-
-## Verify a composition function
-
-View the status of a Function with `kubectl get functions`
-
-During the install a Function reports `INSTALLED` as `True` and `HEALTHY` as
-`Unknown`.
-
-```shell {copy-lines="1"}
-kubectl get functions
-NAME                              INSTALLED   HEALTHY   PACKAGE                                                                  AGE
-function-patch-and-transform      True        Unknown   xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4   10s
-```
-
-After the Function install completes and it's ready for use the `HEALTHY` status
-reports `True`.
-
-## Use a function in a composition
-
-Crossplane calls a Function to determine what resources it should create when
-you create a composite resource. The Function also tells Crossplane what to do
-with these resources when you update or delete a composite resource.
-
-When Crossplane calls a Function it sends it the current state of the composite
-resource. It also sends it the current state of any managed resources the
-composite resource owns.
-
-Crossplane knows what Function to call when a composite resource changes by
-looking at the Composition the composite resource uses.
-
-{{<expand "Confused about Composite Resources and Compositions?" >}}
-Crossplane has four core components that users commonly mix up:
-
-* [Composition]({{<ref "./compositions">}}) - A template to define how to create
-  resources.
-* [CompositeResourceDefinition]({{<ref "./composite-resource-definitions">}})
-  (`XRD`) - A custom API specification. 
-* [Composite Resource]({{<ref "./composite-resources">}}) (`XR`) - Created by
-  using the custom API defined in a CompositeResourceDefinition. XRs use the
-  Composition template to create new managed resources. 
-* [Claim]({{<ref "./claims" >}}) (`XRC`) - Like a Composite Resource, but with
-  namespace scoping. 
-{{</expand >}}
-
-To use composition functions set the Composition 
-{{<hover label="single" line="6">}}mode{{</hover>}} to
-{{<hover label="single" line="6">}}Pipeline{{</hover>}}.
-
-Define a {{<hover label="single" line="7">}}pipeline{{</hover>}} of 
-{{<hover label="single" line="8">}}steps{{</hover>}}. Each 
-{{<hover label="single" line="8">}}step{{</hover>}} calls a Function.  
-
-Each {{<hover label="single" line="8">}}step{{</hover>}} uses a 
-{{<hover label="single" line="9">}}functionRef{{</hover>}} to reference the
-{{<hover label="single" line="10">}}name{{</hover>}} of the Function to call. 
-
-{{<hint "important" >}}
-Compositions using {{<hover label="single" line="6">}}mode: Pipeline{{</hover>}} 
-can't specify resource templates with a `resources` field. 
-
-Use function "Patch and Transform" to create resource templates.
-{{< /hint >}}
-
-
-Some Functions also allow you to specify an 
-{{<hover label="single" line="11">}}input{{</hover>}}.  
-The function defines the
-{{<hover label="single" line="13">}}kind{{</hover>}} of input.
-
-This example uses
-[Function Patch and Transform](https://github.com/crossplane-contrib/function-patch-and-transform).  
-Function Patch and Transform implements Crossplane resource
-templates.  
-The input kind is {{<hover label="single" line="13">}}Resources{{</hover>}}, 
-and it accepts [Patch and Transform]({{<ref "./patch-and-transform">}}) 
-{{<hover label="single" line="14">}}resources{{</hover>}} as input.
-
-```yaml {label="single",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  # Removed for Brevity
-  mode: Pipeline
-  pipeline:
-  - step: patch-and-transform
-    functionRef:
-      name: function-patch-and-transform
-    input:
-      apiVersion: pt.fn.crossplane.io/v1beta1
-      kind: Resources
-      resources:
-      - name: storage-bucket
-        base:
-          apiVersion: s3.aws.upbound.io/v1beta1
-          kind: Bucket
-          spec:
-            forProvider:
-              region: "us-east-2"
-```
-
-
-## Use a pipeline of functions in a composition
-
-Crossplane can ask more than one Function what to do when a composite resource
-changes. When a Composition has a pipeline of two or more steps, Crossplane
-calls them all. It calls them in the order they appear in the pipeline.
-
-Crossplane passes each Function in the pipeline the result of the previous
-Function. This enables powerful combinations of Functions. In this example,
-Crossplane calls {{<hover label="double" line="10">}}function-cue{{</hover>}} to
-create an S3 bucket. Crossplane then passes the bucket to 
-{{<hover label="double" line="23">}}function-auto-ready{{</hover>}}, which marks the
-composite resource as ready when the bucket becomes ready.
-
-```yaml {label="double",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  # Removed for Brevity
-  mode: Pipeline
-  pipeline:
-  - step: cue-export-resources
-    functionRef:
-      name: function-cue
-    input:
-      apiVersion: cue.fn.crossplane.io/v1beta1
-      kind: CUEInput
-      name: storage-bucket
-      export:
-        target: Resources
-        value: |
-          apiVersion: "s3.aws.upbound.io/v1beta1"
-          kind: "Bucket"
-          spec: forProvider: region: "us-east-2"
-  - step: automatically-detect-readiness
-    functionRef:
-      name: function-auto-ready
-```
-
-## Test a composition that uses functions
-
-You can preview the output of any composition that uses composition functions
-using the Crossplane CLI. You don't need a Crossplane control plane to do
-this. The Crossplane CLI uses Docker Engine to run functions.
-
-
-{{<hint "tip">}}
-See the [Crossplane CLI docs]({{<ref "../cli">}}) to
-learn how to install and use the Crossplane CLI.
-{{< /hint >}}
-
-{{<hint "important">}}
-Running `crossplane beta render` requires [Docker](https://www.docker.com).
-{{< /hint >}}
-
-Provide a composite resource, composition and composition functions to render
-the output locally. 
-
-```shell
-crossplane beta render xr.yaml composition.yaml functions.yaml
-```
-
-`crossplane beta render` prints resources as YAML to stdout. It prints the
-composite resource first, followed by the resources the composition functions
-created.
-
-```yaml
----
-apiVersion: example.crossplane.io/v1
-kind: XBucket
-metadata:
-  name: example-render
----
-apiVersion: s3.aws.upbound.io/v1beta1
-kind: Bucket
-metadata:
-  annotations:
-    crossplane.io/composition-resource-name: storage-bucket
-  generateName: example-render-
-  labels:
-    crossplane.io/composite: example-render
-  ownerReferences:
-  - apiVersion: example.crossplane.io/v1
-    blockOwnerDeletion: true
-    controller: true
-    kind: XBucket
-    name: example-render
-    uid: ""
-spec:
-  forProvider:
-    region: us-east-2
-```
-
-{{<expand "The xr.yaml, composition.yaml and function.yaml files used in the example">}}
-
-You can recreate the output below by running `crossplane beta render` with
-these files.
-
-The `xr.yaml` file contains the composite resource to render:
-
-```yaml
-apiVersion: example.crossplane.io/v1
-kind: XBucket
-metadata:
-  name: example-render
-spec:
-  bucketRegion: us-east-2
-```
-
-The `composition.yaml` file contains the Composition to use to render the
-composite resource:
-
-```yaml
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-metadata:
-  name: example-render
-spec:
-  compositeTypeRef:
-    apiVersion: example.crossplane.io/v1
-    kind: XBucket
-  mode: Pipeline
-  pipeline:
-  - step: patch-and-transform
-    functionRef:
-      name: function-patch-and-transform
-    input:
-      apiVersion: pt.fn.crossplane.io/v1beta1
-      kind: Resources
-      resources:
-      - name: storage-bucket
-        base:
-          apiVersion: s3.aws.upbound.io/v1beta1
-          kind: Bucket
-        patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: spec.bucketRegion
-          toFieldPath: spec.forProvider.region
-```
-
-The `functions.yaml` file contains the Functions the Composition references in
-its pipeline steps:
-
-```yaml
----
-apiVersion: pkg.crossplane.io/v1beta1
-kind: Function
-metadata:
-  name: function-patch-and-transform
-spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
-```
-{{</expand>}}
-
-The Crossplane CLI uses Docker Engine to run functions. You can change how the
-Crossplane CLI runs a function by adding an annotation in `functions.yaml`. Add
-the `render.crossplane.io/runtime` annotation to a Function to change how it's
-run.
-
-`crossplane beta render` supports two `render.crossplane.io/runtime` values:
-
-* `Docker` (the default) connects to Docker Engine. It uses Docker to pull and
-  run a function runtime.
-* `Development` connects to a function runtime you have run manually.
-
-When you use the {{<hover label="development" line="6">}}Development{{</hover>}}
-runtime the Crossplane CLI ignores the Function's {{<hover label="development"
-line="8">}}package{{</hover>}}. Instead it expects you to make sure the function
-is listening on localhost port 9443. The function must be listening without gRPC
-transport security. Most function SDKs let you run a function with the
-`--insecure` flag to disable transport security. For example you can run a Go
-function locally using `go run . --insecure`.
-
-```yaml {label="development"}
-apiVersion: pkg.crossplane.io/v1beta1
-kind: Function
-metadata:
-  name: function-patch-and-transform
-  annotations:
-    render.crossplane.io/runtime: Development
-spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
-```
-
-{{<hint "tip">}}
-Use the `Development` runtime when you
-[write a composition function](#write-a-composition-function) to test your
-function end-to-end.
-{{</hint>}}
-
-`crossplane beta render` also supports the following Function annotations. These
-annotations affect how it runs Functions:
-
-* `render.crossplane.io/runtime-docker-cleanup` - When using the `Docker`
-runtime this annotation specifies whether the CLI should stop the function
-container after it calls the function. It supports the values `Stop`, to stop
-the container, and `Orphan`, to leave it running.
-* `render.crossplane.io/runtime-docker-pull-policy` - When using the `Docker`
-  runtime this annotation specifies when the CLI should pull the Function's
-  package. It supports the values `Always`, `Never`, and `IfNotPresent`.
-* `render.crossplane.io/runtime-development-target` - When using the
-  `Development` runtime this annotation tells the CLI to connect to a Function
-  running at the specified target. It uses
-  [gRPC target syntax](https://github.com/grpc/grpc/blob/v1.59.1/doc/naming.md).
-
-## Write a composition function
-
-Composition functions let you replace complicated Compositions with code written
-in your programming language of choice. Crossplane has tools, software
-development kits (SDKs) and templates to help you write a function.
-
-
-<!-- vale write-good.Passive = NO -->
-Here's an example of a tiny, hello world function. This example is written in
-[Go](https://go.dev).
-<!-- vale write-good.Passive = YES -->
-
-```go
-func (f *Function) RunFunction(_ context.Context, req *fnv1beta1.RunFunctionRequest) (*fnv1beta1.RunFunctionResponse, error) {
-        rsp := response.To(req, response.DefaultTTL)
-        response.Normal(rsp, "Hello world!")
-        return rsp, nil
-}
-```
-
-<!-- vale write-good.Passive = NO -->
-Some composition functions are designed to be used with any kind of
-composite resource.
-<!-- vale write-good.Passive = YES -->
-[Function Patch and Transform](https://github.com/crossplane-contrib/function-patch-and-transform)
-and
-[Function Auto Ready](https://github.com/crossplane-contrib/function-auto-ready)
-work with any kind of composite resource.
-
-Another common pattern is to write a composition function specific to one kind
-of composite resource. The function contains all the logic needed to tell
-Crossplane what resources to create when you create a composite resource. When
-you write a composition function like this, your Composition can be small. It
-just tells Crossplane what function to run when you create, update, or delete a
-composite resource.
-
-This Composition tells Crossplane to call {{<hover label="dedicated"
-line="13">}}function-xr-xbucket{{</hover>}} whenever you create, update, or
-delete an {{<hover label="dedicated" line="8">}}XBucket{{</hover>}} composite
-resource. `function-xr-xbucket` is hard coded to handle `XBucket` composite
-resources.
-
-```yaml {label="dedicated"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-metadata:
-  name: example-bucket-function
-spec:
-  compositeTypeRef:
-    apiVersion: example.crossplane.io/v1
-    kind: XBucket
-  mode: Pipeline
-  pipeline:
-  - step: handle-xbucket-xr
-    functionRef:
-      name: function-xr-xbucket
-```
-
-To write a composition function, you:
-
-1. Create the function from a template.
-1. Edit the template to add the function's logic.
-1. [Test the function](#test-a-composition-that-uses-functions).
-1. Build the function, and push it to a package registry.
-
-You use the [Crossplane CLI]({{<ref "../cli">}}) to
-create, test, build, and push a function. For example,
-
-```shell {copy-lines=none}
-# Create the function from a template.
-crossplane beta xpkg init function-example function-template-go
-Initialized package "function-example" in directory "/home/negz/control/negz/function-example" from https://github.com/crossplane/function-template-go/tree/91a1a5eed21964ff98966d72cc6db6f089ad63f4 (main)
-
-$ ls
-Dockerfile  fn.go  fn_test.go  go.mod  go.sum  input  LICENSE  main.go  package  README.md  renovate.json
-
-# Edit the template to add your function's logic
-$ vim fn.go
-
-# Build the function.
-$ docker build . --quiet --tag runtime
-sha256:2c31b0f7a34b34ba5b0b2dacc94c360d18aca1b99f56ca4f40a1f26535a7c1c4
-
-# Package the function.
-$ crossplane xpkg build -f package --embed-runtime-image=runtime
-
-# Test the function.
-$ go run . --insecure
-$ crossplane beta render xr.yaml composition.yaml functions.yaml
-
-# Push the function package to xpkg.upbound.io.
-$ crossplane xpkg push -f package/*.xpkg crossplane-contrib/function-example:v0.1.0
-```
-
-{{<hint "tip">}}
-Crossplane has
-[language specific guides]({{<ref "../guides">}}) to writing
-a composition function. Refer to the guide for your preferred language for a
-more detailed guide to writing a function.
-{{</hint>}}
-
-When you're writing a composition function it's useful to know how composition
-functions work. Read the next section to learn
-[how composition functions work](#how-composition-functions-work).
-
-## How composition functions work
-
-Each composition function is actually a [gRPC](https://grpc.io) server. gRPC is
-a high performance, open source remote procedure call (RPC) framework. When you
-[install a function](#install-a-composition-function) Crossplane deploys the
-function as a gRPC server. Crossplane encrypts and authenticates all gRPC
-communication.
-
-You don't have to be a gRPC expert to write a function. Crossplane's function
-SDKs setup gRPC for you. It's useful to understand how Crossplane calls your
-function though, and how your function should respond.
-
-```mermaid
-sequenceDiagram
-    User->>+API Server: Create composite resource
-    Crossplane Pod->>+API Server: Observe composite resource
-    Crossplane Pod->>+Function Pod: gRPC RunFunctionRequest
-    Function Pod->>+Crossplane Pod: gRPC RunFunctionResponse
-    loop Extra resources needed?
-      Crossplane Pod->>+API Server: Get Extra resources
-      Crossplane Pod->>+Function Pod: gRPC RunFunctionRequest
-      Function Pod->>+Crossplane Pod: gRPC RunFunctionResponse
-    end
-    Crossplane Pod->>+API Server: Apply desired composed resources
-```
-
-When you create, update, or delete a composite resource that uses composition
-functions Crossplane calls each function in the order they appear in the
-Composition's pipeline. Crossplane calls each function by sending it a gRPC
-RunFunctionRequest. The function must respond with a gRPC RunFunctionResponse.
-
-{{<hint "tip">}}
-You can find detailed schemas for the RunFunctionRequest and RunFunctionResponse
-RPCs in the [Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1beta1).
-{{</hint>}}
-
-When Crossplane calls a function the first time it includes four important
-things in the RunFunctionRequest.
-
-1. The __observed state__ of the composite resource, and any composed resources.
-1. The __desired state__ of the composite resource, and any composed resources.
-1. The function's __input__.
-1. The function pipeline's __context__.
-
-A function's main job is to update the __desired state__ and return it to
-Crossplane. It does this by returning a RunFunctionResponse.
-
-Most composition functions read the observed state of the composite resource,
-and use it to add composed resources to the desired state. This tells Crossplane
-which composed resources it should create or update.
-
-If the function needs __extra resources__ to determine the desired state it can
-request any cluster-scoped resource Crossplane already has access to, either by
-by name or labels through the returned RunFunctionResponse. Crossplane then
-calls the function again including the requested __extra resources__ and the
-__context__ returned by the Function itself alongside the same __input__,
-__observed__ and __desired state__ of the previous RunFunctionRequest. Functions
-can iteratively request __extra resources__ if needed, but to avoid endlessly
-looping Crossplane limits the number of iterations to 5. Crossplane considers
-the function satisfied as soon as the __extra resources__ requests become
-stable, so the Function returns the same exact request two times in a row.
-Crossplane errors if stability isn't reached after 5 iterations.
-
-{{<hint "tip">}}
-<!-- vale write-good.Weasel = NO -->
-<!-- Disable Weasel to say "usually", which is correct in this context. -->
-A _composed_ resource is a resource created by a composite resource. Composed
-resources are usually Crossplane managed resources (MRs), but they can be any
-kind of Crossplane resource. For example a composite resource could also create
-a ProviderConfig, or another kind of composite resource. 
-<!-- vale write-good.Weasel = YES -->
-{{</hint>}}
-
-### Observed state
-
-When you create a composite resource like this one, Crossplane _observes_ it and
-sends it to the composition function as part of the observed state.
-
-```yaml
-apiVersion: example.crossplane.io/v1
-kind: XBucket
-metadata:
-  name: example-render
-spec:
-  bucketRegion: us-east-2
-```
-
-If any composed resources already exist, Crossplane observes them and sends them
-to your function as part of the observed state.
-
-Crossplane also observes the connection details of your composite resource and
-any composed resources. It sends them to your function as part of the observed
-state.
-
-Crossplane observes the composite resource and any composed resources once,
-right before it starts calling the functions in the pipeline. This means that
-Crossplane sends every function in the pipeline the same observed state.
-
-### Desired state
-
-Desired state is the set of the changes the function pipeline wants to make to
-the composite resource and any composed resources. When a function adds composed
-resources to the desired state Crossplane creates them.
-
-A function can change:
-
-* The `status` of the composite resource.
-* The `metadata` and `spec` of any composed resource.
-
-A function can also change the connection details and readiness of the composite
-resource. A function indicates that the composite resource is ready by telling
-Crossplane whether its composed resources are ready. When the function pipeline
-tells Crossplane that all composed resources are ready, Crossplane marks the
-composite resource as ready.
-
-A function can't change:
-
-* The `metadata` or `spec` of the composite resource.
-* The `status` of any composed resource.
-* The connection details of any composed resource.
-
-A pipeline of functions _accumulates_ desired state. This means that each
-function builds upon the desired state of previous functions in the pipeline.
-Crossplane sends a function the desired state accumulated by all previous
-functions in the pipeline. The function adds to or updates the desired state and
-then passes it on. When the last function in the pipeline has run, Crossplane
-applies the desired state it returns.
-
-{{<hint "important">}}
-A function __must__ copy all desired state from its RunFunctionRequest to its
-RunFunctionResponse. If a function adds a resource to its desired state the next
-function must copy it to its desired state. If it doesn't, Crossplane doesn't
-apply the resource. If the resource exists, Crossplane deletes it.
-
-A function can _intentionally_ choose not to copy parts of the desired state.
-For example a function may choose not to copy a desired resource to prevent that
-resource from existing.
-
-Most function SDKs handle copying desired state automatically.
-{{</hint>}}
-
-A function should only add the fields it cares about to the desired state. It
-should add these fields every time Crossplane calls it. If a function adds a
-field to the desired state once, but doesn't add it the next time it's called,
-Crossplane deletes the field. The same is true for composed resources. If a
-function adds a composed resource to the desired state, but doesn't add it the
-next time it's called, Crossplane deletes the composed resource.
-
-{{<hint "tip">}}
-Crossplane uses
-[server side apply](https://kubernetes.io/docs/reference/using-api/server-side-apply/)
-to apply the desired state returned by a function pipeline. In server side apply
-terminology, the desired state is a _fully specified intent_.
-{{</hint>}}
-
-For example, if all a function wants is to make sure an S3 bucket in region
-`us-east-2` exists, it should add this resource to its desired composed
-resources.
-
-```yaml
-apiVersion: s3.aws.upbound.io/v1beta1
-kind: Bucket
-spec:
-  forProvider:
-    region: us-east-2
-```
-
-Even if the Bucket already exists and has other `spec` fields, or a `status`,
-`name`, `labels`, etc the function should omit them. The function should only
-include the fields it has an opinion about. Crossplane takes care of applying
-the fields the function cares about, merging them with the existing Bucket.
-
-{{<hint "tip">}}
-Composition functions don't actually use YAML for desired and observed
-resources. This example uses YAML for illustration purposes only.
-{{</hint>}}
-
-### Function input
-
-If a Composition includes {{<hover label="input" line="14">}}input{{</hover>}}
-Crossplane sends it to the function. Input is a useful way to provide extra
-configuration to a function. Supporting input is optional. Not all functions
-support input.
-
-```yaml {label="input",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-metadata:
-  name: example-render
-spec:
-  compositeTypeRef:
-    apiVersion: example.crossplane.io/v1
-    kind: XBucket
-  mode: Pipeline
-  pipeline:
-  - step: patch-and-transform
-    functionRef:
-      name: function-patch-and-transform
-    input:
-      apiVersion: pt.fn.crossplane.io/v1beta1
-      kind: Resources
-      resources:
-      - name: storage-bucket
-        base:
-          apiVersion: s3.aws.upbound.io/v1beta1
-          kind: Bucket
-        patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: spec.bucketRegion
-          toFieldPath: spec.forProvider.region
-```
-
-{{<hint "important">}}
-Crossplane doesn't validate function input. It's a good idea for a function to
-validate its own input.
-{{</hint>}}
-
-### Function pipeline context
-
-Sometimes two functions in a pipeline want to share information with each other
-that isn't desired state. Functions can use context for this. Any function can
-write to the pipeline context. Crossplane passes the context to all following
-functions. When Crossplane has called all functions it discards the pipeline
-context.
-
-Crossplane can write context too. If you enable the alpha
-[composition environment]({{<ref "environment-configs">}}) feature Crossplane
-writes the environment to the top-level context field
-`apiextensions.crossplane.io/environment`.
-
-## Disable composition functions
-
-Crossplane enables composition functions by default. Disable support for
-composition functions by disabling the beta feature flag in Crossplane with
-`helm install --args`.
-
-```shell
-helm install crossplane --namespace crossplane-system crossplane-stable/crossplane \
-    --create-namespace \
-    --set "args='{--enable-composition-functions=false}'"
-```
-
-The preceding Helm command installs Crossplane with the composition functions
-feature flag disabled. Confirm you have disabled composition functions by
-looking for a log line:
-
-```shell {copy-lines="1"}
- kubectl -n crossplane-system logs -l app=crossplane
-{"level":"info","ts":1674535093.36186,"logger":"crossplane","msg":"Beta feature enabled","flag":"EnableBetaCompositionFunctions"}
-```
-
-If you don't see the log line emitted when Crossplane starts, you have disabled
-composition functions.
-
-## Disable extra resources
-
-Crossplane enables __extra resources__ by default, allowing Functions to get access
-to any cluster-scoped resource Crossplane already has access to. Disable support
-for __extra resources__, while keeping composition functions enabled, by disabling
-the beta feature flag in Crossplane with `helm install --args`.
-
-```shell
-helm install crossplane --namespace crossplane-system crossplane-stable/crossplane \
-    --create-namespace \
-    --set "args='{--enable-composition-functions-extra-resources=false}'"
-```
-
-The preceding Helm command installs Crossplane with the extra resources
-feature flag disabled. Confirm you have disabled composition functions by
-looking for a log line:
-
-```shell {copy-lines="1"}
- kubectl -n crossplane-system logs -l app=crossplane
-{"level":"info","ts":1674535093.36186,"logger":"crossplane","msg":"Beta feature enabled","flag":"EnableBetaCompositionFunctionsExtraResources"}
-```
-
-If you don't see the log line emitted when Crossplane starts, you have disabled
-__extra resources__ for composition functions, which means requests by functions for __extra
-resources__ are just ignored.
diff --git a/content/master/concepts/composition-revisions.md b/content/master/concepts/composition-revisions.md
index 9be65950..c2c8b519 100644
--- a/content/master/concepts/composition-revisions.md
+++ b/content/master/concepts/composition-revisions.md
@@ -170,17 +170,25 @@ spec:
   compositeTypeRef:
     apiVersion: aws.example.upbound.io/v1alpha1
     kind: MyVPC
-  resources:
-  - base:
-      apiVersion: ec2.aws.upbound.io/v1beta1
-      kind: VPC
-      spec:
-        forProvider:
-          region: us-west-1
-          cidrBlock: 192.168.0.0/16
-          enableDnsSupport: true
-          enableDnsHostnames: true
-    name: my-vcp
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: my-vpc
+        base:
+          apiVersion: ec2.aws.upbound.io/v1beta1
+          kind: VPC
+          spec:
+            forProvider:
+              region: us-west-1
+              cidrBlock: 192.168.0.0/16
+              enableDnsSupport: true
+              enableDnsHostnames: true
 ```
 
 Apply the example XRD.
@@ -382,17 +390,25 @@ spec:
   compositeTypeRef:
     apiVersion: aws.example.upbound.io/v1alpha1
     kind: MyVPC
-  resources:
-  - base:
-      apiVersion: ec2.aws.upbound.io/v1beta1
-      kind: VPC
-      spec:
-        forProvider:
-          region: us-west-1
-          cidrBlock: 192.168.0.0/16
-          enableDnsSupport: false
-          enableDnsHostnames: true
-    name: my-vcp
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: my-vpc
+        base:
+          apiVersion: ec2.aws.upbound.io/v1beta1
+          kind: VPC
+          spec:
+            forProvider:
+              region: us-west-1
+              cidrBlock: 192.168.0.0/16
+              enableDnsSupport: false
+              enableDnsHostnames: true
 ```
 
 Expected Output:
diff --git a/content/master/concepts/compositions.md b/content/master/concepts/compositions.md
index 746eec63..ba8e2371 100644
--- a/content/master/concepts/compositions.md
+++ b/content/master/concepts/compositions.md
@@ -3,6 +3,8 @@ title: Compositions
 weight: 30
 aliases: 
   - composition
+  - composition-functions
+  - /knowledge-base/guides/composition-functions
 description: "Compositions are a template for creating Crossplane resources"
 ---
 
@@ -16,6 +18,39 @@ An example Composition may combine a virtual machine, storage resources and
 networking policies. A Composition template links all these individual
 resources together. 
 
+Here's an example Composition. When you create an
+{{<hover label="intro" line="8">}}AcmeBucket{{</hover >}} composite resource
+(XR) that uses this Composition, Crossplane will create the templated Amazon S3
+{{<hover label="intro" line="18">}}Bucket{{</hover >}} managed resource.
+
+```yaml {label="intro"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: example
+spec:
+  compositeTypeRef:
+    apiVersion: custom-api.example.org/v1alpha1
+    kind: AcmeBucket
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: storage-bucket
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+          spec:
+            forProvider:
+              region: "us-east-2"
+```
+
+
 {{<expand "Confused about Compositions, XRDs, XRs and Claims?" >}}
 Crossplane has four core components that users commonly mix up:
 
@@ -29,385 +64,210 @@ Crossplane has four core components that users commonly mix up:
   with namespace scoping. 
 {{</expand >}}
 
-## Creating Compositions
+## Create a Composition
 
-Creating Compositions consists of:
-* [Resource templates](#resource-templates) defining the resources to create.
-* [Enabling Composite Resources](#enabling-composite-resources) to use this
+Creating a Composition consists of:
+* [Using composition functions](#use-a-function-in-a-composition) to define the
+  resources to create.
+* [Enabling composite resources](#enable-composite-resources) to use the
   Composition template.
 
-<!-- vale Google.WordList = NO -->
-Optionally, Compositions also support:
-* [Modifying and patching](#changing-resource-fields) resource settings.
-* [Storing connection details](#storing-connection-details) and secrets
-  generated by the managed resources.
-* Using [Composition Functions](#use-composition-functions) to template
-  resources using custom programs. 
-* Creating a 
-  [custom check of when a resource is ready](#resource-readiness-checks) 
-  to use. 
-<!-- vale Google.WordList = YES -->
- 
-###  Resource templates
-The 
-{{<hover label="resources" line="4">}}resources{{</hover>}} field of a 
-Composition's 
-{{<hover label="resources" line="3">}}spec{{</hover>}} 
-defines the set of things that a Composite Resource creates.
+A Composition is a pipeline of composition functions.
 
-{{<hint "note" >}}
-Read more about Composite Resources in the 
-[Composite Resources page]({{<ref "./composite-resources" >}}). 
-{{< /hint >}}
-  
-
-For example, a Composition can define a template to create a virtual machine 
-and an associated storage bucket at the same time. 
-
-The {{<hover label="resources" line="4">}}resources{{</hover>}} field lists the 
-individual resources with a 
-{{<hover label="resources" line="5">}}name{{</hover>}}.  
-This name identifies the
-resource inside the Composition and isn't related to the external name used with
-the Provider.
-
-#### Template a managed resource
-The contents of the 
-{{<hover label="resources" line="6">}}base{{</hover>}} are identical to
-creating a standalone [managed resource]({{<ref "./managed-resources">}}).
-
-This example uses 
-[Upbound's Provider AWS](https://marketplace.upbound.io/providers/upbound/provider-aws/v0.35.0)
-to define a 
-S3 storage {{<hover label="resources" line="8">}}Bucket{{</hover>}} and 
-EC2 compute {{<hover label="resources" line="15">}}Instance{{</hover>}}.
-
-After defining the 
-{{<hover label="resources" line="7">}}apiVersion{{</hover>}} and 
-{{<hover label="resources" line="8">}}kind{{</hover>}}, define the 
-{{<hover label="resources" line="10">}}spec.forProvider{{</hover>}} fields
-defining the settings of the resource.
-
-```yaml {copy-lines="none",label="resources"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  resources:
-    - name: StorageBucket
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: "us-east-2"
-    - name: VM
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: Instance
-        spec:
-          forProvider:
-            ami: ami-0d9858aa3c6322f73
-            instanceType: t2.micro
-            region: "us-east-2"
-```
+Composition functions (or just functions, for short) are Crossplane extensions
+that template Crossplane resources. Crossplane calls the composition functions
+to determine what resources it should create when you create a composite
+resource (XR).
 
-When a [Composite Resource]({{<ref "./composite-resources" >}}) uses this
-Composition template, the Composite Resource creates two new managed resources
-with all the provided 
-{{<hover label="resources" line="17">}}spec.forProvider{{</hover>}} settings.
-
-The {{<hover label="resources" line="16">}}spec{{</hover>}}
-supports any settings used in a managed resource including
-applying `annotations` and `labels` or using a specific 
-`providerConfigRef`.
-
-{{<hint "note" >}}
-Compositions allow applying a `metadata.name` to a resource's 
-{{<hover label="resources" line="16">}}spec{{</hover>}} but ignores it. The
-`metadata.name` field doesn't influence the name
-of the managed resource in Crossplane or the external resource inside the 
-Provider.
-
-Use the `crossplane.io/external-name` annotation on the resource to influence
-the external resource name.
+{{<hint "tip" >}}
+The Crossplane community has built lots of functions that let you template
+Crossplane resources using
+[CUE](https://github.com/crossplane-contrib/function-cue), Helm-like
+[Go templates](https://github.com/crossplane-contrib/function-go-templating) or
+legacy Crossplane
+[Patch and Transforms]({{<ref "../guides/function-patch-and-transform">}}).
+
+You can also [write your own function](#write-a-composition-function) using Go
+or Python.
 {{< /hint >}}
 
-#### Template a ProviderConfig
+{{<hint "important" >}}
+Crossplane has two modes of composition:
 
-Compositions can define a ProviderConfig like it defines managed resources.
-Generating a ProviderConfig may be useful in providing unique credentials to
-each deployment.
+* `mode: Pipeline`
+* `mode: Resources`
 
+Use the `Pipeline` mode to use composition functions.
 
-```yaml {copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  resources:
-    - name: my-aws-provider-config
-      base:
-        apiVersion: aws.upbound.io/v1beta1
-        kind: ProviderConfig
-        spec:
-          source: Secret
-          secretRef:
-            namespace: crossplane-system
-            name: aws-secret
-            key: creds
-```
+<!-- vale write-good.Passive = NO -->
+The `Resources` mode is deprecated, and you shouldn't use it. Crossplane
+supports Compositions that use the `Resources` mode for backward compatibility,
+but the feature is no longer maintained. Crossplane doesn't accept new
+`Resources` features, and only accepts security bug fixes.
+<!-- vale write-good.Passive = YES -->
 
+See the [CLI documentation]({{<ref "../cli">}}) to learn how to use the
+`crossplane beta convert` command to convert a legacy `Resources` Composition to
+the `Pipeline` mode. 
+{{< /hint >}}
 
-#### Template another Composite Resource
 
-Compositions can use other Composite Resources to define more complicated
-templates. 
+### Install a composition function
 
-A common use case is a Composition that uses other
-Compositions. For example, creating a Composition to create a standard set of 
-networking resources that other Compositions reference. 
+Installing a Function creates a function pod. Crossplane sends requests to this
+pod to ask it what resources to create when you create a composite resource.
 
-{{< hint "note" >}}
-Both Compositions must have corresponding XRDs.
-{{< /hint >}}
+Install a Function with a Crossplane
+{{<hover label="install" line="2">}}Function{{</hover >}} object setting the
+{{<hover label="install" line="6">}}spec.package{{</hover >}} value to the
+location of the function package.
 
-This example networking Composition defines the set of resources required to 
-create a new AWS virtual network. This includes a 
-{{<hover label="xnetwork" line="8">}}VPC{{</hover>}},
-{{<hover label="xnetwork" line="13">}}InternetGateway{{</hover>}} and
-{{<hover label="xnetwork" line="18">}}Subnet{{</hover>}}.
 
-```yaml {copy-lines="none",label="xnetwork"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
+For example, to install [Function Patch and Transform]({{<ref "../guides/function-patch-and-transform">}}),
+
+```yaml {label="install"}
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
 spec:
-  resources:
-    - name: vpc-resource
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        # Removed for Brevity
-    - name: gateway-resource
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: InternetGateway
-        # Removed for Brevity
-    - name: subnet-resource
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: Subnet
-        # Removed for Brevity
-  compositeTypeRef:
-    apiVersion: aws.platformref.upbound.io/v1alpha1
-    kind: XNetwork
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
 ```
 
-The {{<hover label="xnetwork" line="20">}}compositeTypeRef{{</hover>}} gives
-this Composition an 
-{{<hover label="xnetwork" line="21">}}apiVersion{{</hover>}} and
-{{<hover label="xnetwork" line="22">}}kind{{</hover>}} to reference in another
-Composition. 
-
-{{<hint "note" >}}
-The [Enabling a Composite Resource](#enabling-composite-resources) section 
-describes the 
-{{<hover label="xnetwork" line="20">}}compositeTypeRef{{</hover>}} field.
+{{< hint "tip" >}}
+Functions are Crossplane Packages. Read more about Packages in the
+[Packages documentation]({{<ref "packages" >}}).
 {{< /hint >}}
 
-A second Composition, defining other resources, in this example, an AWS Elastic
-Kubernetes Cluster, can reference the previous
-{{<hover label="xnetwork" line="22">}}XNetwork{{</hover>}}
+By default, the Function pod installs in the same namespace as Crossplane
+(`crossplane-system`).
 
-```yaml {copy-lines="none",label="xcluster"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  resources:
-    - name: nested-network-composition
-      base:
-        apiVersion: aws.platformref.upbound.io/v1alpha1
-        kind: XNetwork
-        # Removed for brevity
-    - name: eks-cluster-resource
-      base:
-        apiVersion: eks.aws.upbound.io/v1beta1
-        kind: Cluster
-        # Removed for brevity
-```
+### Verify a composition function
 
-When a Composite Resource creates all the managed resources from this 
-Composition, the resources defined by the 
-{{<hover label="xcluster" line="8">}}XNetwork{{</hover>}} get created along with
-the EKS {{<hover label="xcluster" line="13">}}cluster{{</hover >}}. 
+View the status of a Function with `kubectl get functions`
 
-{{<hint "note" >}}
-This abbreviated example is from the Upbound 
-[AWS Reference Platform](https://github.com/upbound/platform-ref-aws).
+During the install a Function reports `INSTALLED` as `True` and `HEALTHY` as
+`Unknown`.
 
-View the complete Compositions in the reference platform's 
-[package directory](https://github.com/upbound/platform-ref-aws/blob/main/apis/cluster/composition.yaml).
-{{</hint >}}
+```shell {copy-lines="1"}
+kubectl get functions
+NAME                              INSTALLED   HEALTHY   PACKAGE                                                                  AGE
+function-patch-and-transform      True        Unknown   xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4   10s
+```
 
-#### Cross-resource references
+After the Function install completes and it's ready for use the `HEALTHY` status
+reports `True`.
 
-Inside a Composition some resources use identifiers or names of other resources.
-For example, creating a new `network` and applying the network identifier to a
-virtual machine. 
+### Use a function in a composition
 
-Resources inside a Composition can cross-reference other resources by matching
-a label or a _controller reference_.
+Crossplane calls a Function to determine what resources it should create when
+you create a composite resource. The Function also tells Crossplane what to do
+with these resources when you update or delete a composite resource.
 
-{{<hint "note" >}}
-Providers allow matching of labels and controller references on a
-per-resource basis. Check the documentation for the specific Provider resource
-to see what's supported.  
+When Crossplane calls a Function it sends it the current state of the composite
+resource. It also sends it the current state of any managed resources the
+composite resource owns.
 
-Matching labels and controllers isn't supported across different Providers.
-{{< /hint >}}
+Crossplane knows what Function to call when a composite resource changes by
+looking at the Composition the composite resource uses.
 
-##### Match resource labels
-
-To match a resource label, first apply a 
-{{<hover label="matchlabel" line="11">}}label{{</hover>}} to the resource to 
-match and use
-{{<hover label="matchlabel" line="19">}}matchLabels{{</hover>}} 
-in the second resource.
-
-This example creates a AWS 
-{{<hover label="matchlabel" line="7">}}Role{{</hover>}} and applies a 
-{{<hover label="matchlabel" line="11">}}label{{</hover>}}. The second resource
-is a {{<hover label="matchlabel" line="14">}}RolePolicyAttachment{{</hover>}},
-which requires attaching to an existing `Role`. 
-
-Using the resource's 
-{{<hover label="matchlabel" line="19">}}roleSelector.matchLabels{{</hover>}}
-ensures this 
-{{<hover label="matchlabel" line="14">}}RolePolicyAttachment{{</hover>}}
-references the matching 
-{{<hover label="matchlabel" line="7">}}Role{{</hover>}}, even if the unique role
-identifier isn't known. 
-
-```yaml {label="matchlabel",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  resources:
-    - base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: Role
-        name: iamRole
-        metadata:
-          labels:
-            role: controlplane
-    - base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: RolePolicyAttachment
-        name: iamPolicy
-        spec:
-          forProvider:
-            roleSelector:
-              matchLabels:
-                role: controlplane
-  # Removed for brevity
-```
+To use composition functions set the Composition 
+{{<hover label="single" line="6">}}mode{{</hover>}} to
+{{<hover label="single" line="6">}}Pipeline{{</hover>}}.
 
-##### Match a controller reference 
+Define a {{<hover label="single" line="7">}}pipeline{{</hover>}} of 
+{{<hover label="single" line="8">}}steps{{</hover>}}. Each 
+{{<hover label="single" line="8">}}step{{</hover>}} calls a Function.  
 
-Matching a controller reference ensures that the matching resource is
-in the same composite resource. 
+Each {{<hover label="single" line="8">}}step{{</hover>}} uses a 
+{{<hover label="single" line="9">}}functionRef{{</hover>}} to reference the
+{{<hover label="single" line="10">}}name{{</hover>}} of the Function to call. 
 
-Matching only a controller reference simplifies the matching process without
-requiring labels or more information. 
+{{<hint "important" >}}
+Compositions using {{<hover label="single" line="6">}}mode: Pipeline{{</hover>}} 
+can't specify resource templates with a `resources` field. 
+
+Use function "Patch and Transform" to create resource templates.
+{{< /hint >}}
 
-For example, creating an AWS 
-{{<hover label="controller1" line="14">}}InternetGateway{{</hover>}} requires a
-{{<hover label="controller1" line="7">}}VPC{{</hover>}}.
 
-The {{<hover label="controller1" line="14">}}InternetGateway{{</hover>}} could
-match a label, but every VPC created by this Composition share the same label. 
+Some Functions also allow you to specify an 
+{{<hover label="single" line="11">}}input{{</hover>}}.  
+The function defines the
+{{<hover label="single" line="13">}}kind{{</hover>}} of input.
 
-Using {{<hover label="controller1" line="19">}}matchControllerRef{{</hover>}}
-matches only the VPC created in the same composite resource that created the 
-{{<hover label="controller1" line="14">}}InternetGateway{{</hover>}}. 
+This example uses
+[Function Patch and Transform]({{<ref "../guides/function-patch-and-transform">}}).
+Function Patch and Transform implements Crossplane resource
+templates.  
+The input kind is {{<hover label="single" line="13">}}Resources{{</hover>}}, 
+and it accepts  {{<hover label="single" line="14">}}resources{{</hover>}} as input.
 
-```yaml {label="controller1",copy-lines="none"}
+```yaml {label="single",copy-lines="none"}
 apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
+# Removed for Brevity
 spec:
-  resources:
-    - base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        name: my-vpc
-        spec:
-          forProvider:
-          # Removed for brevity
-    - base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: InternetGateway
-        name: my-gateway
-        spec:
-          forProvider:
-            vpcIdSelector:
-              matchControllerRef: true
-# Removed for brevity
+  # Removed for Brevity
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: storage-bucket
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+          spec:
+            forProvider:
+              region: "us-east-2"
 ```
 
+### Use a pipeline of functions in a composition
 
-Resources can match both labels and a controller reference to match a specific
-resource in the larger composite resource. 
-
-For example, this Composition creates two 
-{{<hover label="controller2" line="17">}}VPC{{</hover>}}
-resources, but the 
-{{<hover label="controller2" line="27">}}InternetGateway{{</hover>}} 
-must match only one. 
+Crossplane can ask more than one Function what to do when a composite resource
+changes. When a Composition has a pipeline of two or more steps, Crossplane
+calls them all. It calls them in the order they appear in the pipeline.
 
-Applying a {{<hover label="controller2" line="21">}}label{{</hover>}} to the 
-second {{<hover label="controller2" line="17">}}VPC{{</hover>}} allows the 
-{{<hover label="controller2" line="27">}}InternetGateway{{</hover>}} to match
-the label
-{{<hover label="controller2" line="34">}}type: internet{{</hover>}} and only
-match objects in the same composite resource with 
-{{<hover label="controller2" line="32">}}matchControllerRef{{</hover>}}.
+Crossplane passes each Function in the pipeline the result of the previous
+Function. This enables powerful combinations of Functions. In this example,
+Crossplane calls {{<hover label="double" line="10">}}function-cue{{</hover>}} to
+create an S3 bucket. Crossplane then passes the bucket to 
+{{<hover label="double" line="23">}}function-auto-ready{{</hover>}}, which marks the
+composite resource as ready when the bucket becomes ready.
 
-```yaml {label="controller2",copy-lines="none"}
+```yaml {label="double",copy-lines="none"}
 apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
+# Removed for Brevity
 spec:
-  resources:
-    - base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        name: my-first-vpc
-        metadata:
-          labels:
-            type: backend
-        spec:
-          forProvider:
-          # Removed for brevity
-    - base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        name: my-second-vpc
-        metadata:
-          labels:
-            type: internet
-        spec:
-          forProvider:
-          # Removed for brevity
-    - base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: InternetGateway
-        name: my-gateway
-        spec:
-          forProvider:
-            vpcIdSelector:
-              matchControllerRef: true
-              matchLabels:
-                type: internet
-# Removed for brevity
+  # Removed for Brevity
+  mode: Pipeline
+  pipeline:
+  - step: cue-export-resources
+    functionRef:
+      name: function-cue
+    input:
+      apiVersion: cue.fn.crossplane.io/v1beta1
+      kind: CUEInput
+      name: storage-bucket
+      export:
+        target: Resources
+        value: |
+          apiVersion: "s3.aws.upbound.io/v1beta1"
+          kind: "Bucket"
+          spec: forProvider: region: "us-east-2"
+  - step: automatically-detect-readiness
+    functionRef:
+      name: function-auto-ready
 ```
-### Enabling Composite Resources
+
+
+### Enable composite resources
 
 A Composition is only a template defining how to create managed 
 resources. A Composition limits which Composite Resources can use this
@@ -440,326 +300,32 @@ spec:
   # Removed for brevity
 ```
 
-### Changing resource fields
-
-Most Compositions require customizing the fields of the resources. This can
-include applying unique passwords, modifying where to deploy resources,
-or applying labels or annotations. 
-
-The primary method to change resources is using a resource 
-[patch and transform]({{<ref "./patch-and-transform" >}}). Patch and transforms 
-allow matching specific input fields, modifying them and applying them to the 
-managed resource. 
-
-{{<hint "important" >}}
-The details of creating patch and transforms and their options are in the 
-[Patch and Transform page]({{<ref "./patch-and-transform" >}}).
-
-This section describes applying patches and transforms to Compositions.
-{{< /hint >}}
-
-Apply patches to individual `resources` with the 
-{{<hover label="patch" line="13">}}patches{{</hover>}}
-field. 
-
-For example, taking the 
-{{<hover label="patchClaim" line="6">}}location{{</hover>}} provided in a Claim 
-and applying it to the 
-{{<hover label="patch" line="12">}}region{{</hover>}} value in the managed 
-resource.
-
-```yaml {copy-lines="none",label="patchClaim"}
-apiVersion: example.org/v1alpha1
-kind: ExampleClaim
-metadata:
-  name: my-example-claim
-spec:
-  location: "eu-north-1"
-```
-
-The Composition patch uses the 
-{{<hover label="patch" line="15">}}fromFieldPath{{</hover>}} to match the 
-{{<hover label="patchClaim" line="6">}}location{{</hover>}}
-field in the Claim and the 
-{{<hover label="patch" line="16">}}toFieldPath{{</hover>}} to define which field
-to change inside the Composition. 
-
-```yaml {copy-lines="none",label="patch"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  resources:
-    - name: s3Bucket
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: "us-east-2"
-      patches:
-      - type: FromCompositeFieldPath
-        fromFieldPath: "spec.location"
-        toFieldPath: "spec.forProvider.region"
-```
-
-#### Patch sets
-
-Some Compositions have resources which need identical patches applied. Instead
-of repeating the same `patches` field, resources can reference a single 
-`patchSet`. 
-
-Define a {{<hover label="patchset" line="5">}}patchSet{{</hover>}} with a 
-{{<hover label="patchset" line="6">}}name{{</hover>}}
-and 
-{{<hover label="patchset" line="7">}}patch{{</hover>}}
-operations. 
-
-Then apply the 
-{{<hover label="patchset" line="5">}}patchSet{{</hover>}}
-to each resource with 
-{{<hover label="patchset" line="16">}}type: patchSet{{< /hover >}}, referencing
-the {{<hover label="patchset" line="6">}}name{{< /hover >}} in the 
-{{<hover label="patchset" line="17">}}patchSetName{{< /hover >}} field.
-
-```yaml {copy-lines="none",label="patchset"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  patchSets:
-    - name: reusable-patch
-      patches:
-      - type: FromCompositeFieldPath
-        fromFieldPath: "location"
-        toFieldPath: "spec.forProvider.region"
-  resources:
-    - name: first-resource
-      base:
-      # Removed for Brevity
-      patches:
-        - type: PatchSet
-          patchSetName: reusable-patch
-    - name: second-resource
-      base:
-      # Removed for Brevity
-      patches:
-        - type: PatchSet
-          patchSetName: reusable-patch
-```
-
-#### Patch with EnvironmentConfigs 
-
-Crossplane uses EnvironmentConfigs to create in-memory data stores. Compositions 
-can read and write from this data store as part of the patch process. 
-
-{{<hint "important" >}}
-EnvironmentConfigs are an alpha feature. Alpha features aren't enabled by
-default. 
-{{< /hint >}}
-
- EnvironmentConfigs can predefine data that Compositions can use
- or a Composite Resource can write data to their in-memory environment for other
- resources to read. 
-
-<!-- vale off -->
-{{< hint "note" >}}
-<!-- vale on --> 
-Read the [EnvironmentConfigs]({{<ref "./environment-configs" >}}) page for 
-more information on using EnvironmentConfigs.
-{{< /hint >}}
-
-To apply a patch using EnvironmentConfigs, first define which EnvironmentConfigs
-to use with 
-{{<hover label="envselect" line="6">}}environment.environmentConfigs{{</hover>}}. 
-
-<!-- vale Google.Quotes = NO -->
-<!-- vale gitlab.SentenceLength = NO -->
-<!-- ignore false positive -->
-Use either a
-[reference]({{<ref "./managed-resources#matching-by-name-reference" >}})
-or a [selector]({{<ref "./managed-resources#matching-by-selector" >}}) to
-identify the EnvironmentConfigs to use.
-<!-- vale Google.Quotes = YES -->
-
-```yaml {label="envselect",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  environment:
-    environmentConfigs:
-      - ref:
-          name: example-environment
-  resources:
-  # Removed for Brevity
-```
-
-<!-- these two sections are duplicated in the environment-configs doc --> 
-
-##### Patch a composite resource
-To patch between the composite resource and the in-memory environment use
-{{< hover label="xrpatch" line="7">}}patches{{</hover>}} inside of the 
-{{< hover label="xrpatch" line="5">}}environment{{</hover>}}.
-
-Use the 
-{{< hover label="xrpatch" line="5">}}ToCompositeFieldPath{{</hover>}} to copy
-data from the in-memory environment to the composite resource.  
-Use the 
-{{< hover label="xrpatch" line="5">}}FromCompositeFieldPath{{</hover>}} to copy
-data from the composite resource to the in-memory environment.
-
-```yaml {label="xrpatch",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  environment:
-  # Removed for Brevity
-      patches:
-      - type: ToCompositeFieldPath
-        fromFieldPath: tags
-        toFieldPath: metadata.labels[envTag]
-      - type: FromCompositeFieldPath
-        fromFieldPath: metadata.name
-        toFieldPath: newEnvironmentKey
-```
-
-Individual resources can use any data written to their in-memory environment.
-
-##### Patch an individual resource
-To patch an individual resource, inside the 
-{{<hover label="envpatch" line="16">}}patches{{</hover>}} of the 
-resource, use 
-{{<hover label="envpatch" line="17">}}ToEnvironmentFieldPath{{</hover>}} to copy
-data from the resource to the in-memory environment.  
-Use {{<hover label="envpatch" line="20">}}FromEnvironmentFieldPath{{</hover>}}
-to copy data to the resource from the in-memory environment.
-
-```yaml {label="envpatch",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  environment:
-  # Removed for Brevity
-  resources:
-  # Removed for Brevity
-    - name: vpc
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        spec:
-          forProvider:
-            cidrBlock: 172.16.0.0/16
-      patches:
-        - type: ToEnvironmentFieldPath
-          fromFieldPath: status.atProvider.id
-          toFieldPath: vpcId
-        - type: FromEnvironmentFieldPath
-          fromFieldPath: tags
-          toFieldPath: spec.forProvider.tags
-```
-
-The [EnvironmentConfigs]({{<ref "./environment-configs" >}}) page has 
-more information on EnvironmentConfigs options and usage.
-
-### Use composition functions
-
-Composition functions (or just functions, for short) are custom programs that
-template Crossplane resources. You can write a function to template resources
-using a general purpose programming language like Go or Python. Using a general
-purpose programming language allows a function to use more advanced logic to
-template resources, like loops and conditionals.
-
-{{<hint "important" >}}
-Composition functions is a beta feature. Crossplane enables beta functions by
-default. The
-[Composition Functions]({{<ref "./composition-functions#disable-composition-functions">}})
-page explains how to disable composition functions.
-{{< /hint >}}
-
-To use composition functions set the Composition 
-{{<hover label="xfn" line="6">}}mode{{</hover>}} to
-{{<hover label="xfn" line="6">}}Pipeline{{</hover>}}.
-
-Define a {{<hover label="xfn" line="7">}}pipeline{{</hover>}} of 
-{{<hover label="xfn" line="8">}}steps{{</hover>}}. Each 
-{{<hover label="xfn" line="8">}}step{{</hover>}} calls a Function.  
-
-Each {{<hover label="xfn" line="8">}}step{{</hover>}} uses a 
-{{<hover label="xfn" line="9">}}functionRef{{</hover>}} to reference the
-{{<hover label="xfn" line="10">}}name{{</hover>}} of the Function to call. 
-
-Some Functions also allow you to specify an 
-{{<hover label="xfn" line="11">}}input{{</hover>}}.  
-The function defines the
-{{<hover label="xfn" line="13">}}kind{{</hover>}} of input.
-
-{{<hint "important" >}}
-Compositions using {{<hover label="xfn" line="6">}}mode: Pipeline{{</hover>}} 
-can't specify resource templates with a `resources` field. 
-
-Use function "Patch and Transform" to create resource templates.
-{{< /hint >}}
-
-This example uses Function Patch and Transform. Function Patch and Transform is
-a function that implements Crossplane resource templates. You can use Function
-Patch and Transform to specify resource templates in a pipeline with other
-Functions.
-
-```yaml {label="xfn",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  # Removed for Brevity
-  mode: Pipeline
-  pipeline:
-  - step: patch-and-transform
-    functionRef:
-      name: function-patch-and-transform
-    input:
-      apiVersion: pt.fn.crossplane.io/v1beta1
-      kind: Resources
-      resources:
-      - name: storage-bucket
-        base:
-          apiVersion: s3.aws.upbound.io/v1beta1
-          kind: Bucket
-          spec:
-            forProvider:
-              region: "us-east-2"
-```
-
-Read the [composition functions]({{<ref "./composition-functions">}}) page for
-details on building and using composition functions.
-
-### Storing connection details
+### Store connection details
 
-Some managed resources generate unique details like usernames, passwords, 
-IP addresses, ports or other connection details. 
+Some managed resources generate unique details like usernames, passwords, IP
+addresses, ports or other connection details. 
 
 When resources inside a Composition create connection details Crossplane creates
-a Kubernetes secret object for each managed resource generating connection 
+a Kubernetes secret object for each managed resource generating connection
 details. 
 
 {{<hint "note">}}
 This section discusses creating Kubernetes secrets.  
-Crossplane also supports using external secret stores like [HashiCorp Vault](https://www.vaultproject.io/). 
+Crossplane also supports using external secret stores like
+[HashiCorp Vault](https://www.vaultproject.io/). 
 
 Read the [external secrets store guide]({{<ref "../guides/vault-as-secret-store">}}) for more information on using Crossplane
 with an external secret store. 
 {{</hint >}}
 
 #### Composite resource combined secret
+
 Crossplane can combine all the secrets generated by the resources inside a
-Composition into a single Kubernetes secret and optionally copy the
-secret object for [Claims]({{<ref "./claims#claim-connection-secrets">}}). 
+Composition into a single Kubernetes secret and optionally copy the secret
+object for claims. 
 
-Set the value of 
-{{<hover label="writeConn" line="5">}}writeConnectionSecretsToNamespace{{</hover>}}
-to the namespace where Crossplane should store the combined secret object.
+Set the value of `writeConnectionSecretsToNamespace` to the namespace where
+Crossplane should store the combined secret object.
 
 ```yaml {copy-lines="none",label="writeConn"}
 apiVersion: apiextensions.crossplane.io/v1
@@ -772,42 +338,41 @@ spec:
 ```
 
 #### Composed resource secrets
-Inside the 
-{{<hover label="writeConnRes" line="10">}}spec{{</hover>}} of 
-each resource producing connection details, define the 
-{{<hover label="writeConnRes" line="13">}}writeConnectionSecretToRef{{</hover>}}, with
-a 
-{{<hover label="writeConnRes" line="14">}}namespace{{</hover>}} and 
-{{<hover label="writeConnRes" line="15">}}name{{</hover>}} of the secret object for
-the resource.  
 
-If a 
-{{<hover label="writeConnRes" line="13">}}writeConnectionSecretToRef{{</hover>}}
-isn't defined, Crossplane doesn't write any keys to the secret.
+Inside the `spec` of each resource producing connection details, define the
+`writeConnectionSecretToRef`, with a `namespace` and `name` of the secret object
+for the resource.  
 
+If a `writeConnectionSecretToRef` isn't defined, Crossplane doesn't write any
+keys to the secret.
 
 ```yaml {label="writeConnRes"}
 apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
   writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
 ```
 
-Crossplane saves a secret with the 
-{{<hover label="viewComposedSec" line="3">}}name{{</hover>}}
-in the 
-{{<hover label="writeConnRes" line="14">}}namespace{{</hover>}} provided.
+Crossplane saves a secret with the `name` in the `namespace` provided.
 
 ```shell {label="viewComposedSec"}
 kubectl get secrets -n docs
@@ -816,161 +381,10 @@ key1   connection.crossplane.io/v1alpha1   4      4m30s
 ```
 
 {{<hint "tip" >}}
-
-Crossplane recommends using a [Patch]({{<ref "./patch-and-transform">}}) to
-create a unique name for each secret. 
-
-For example, a 
-{{<hover label="tipPatch" line="15">}}patch{{</hover>}}
-to add the unique identifier of the resource as the key
-name.
-
-```yaml {label="tipPatch",copy-lines="14-20"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  # Removed for brevity
-  resources:
-    - name: key
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-        # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      patches:
-        - fromFieldPath: "metadata.uid"
-          toFieldPath: "spec.writeConnectionSecretToRef.name"
-          transforms:
-            - type: string
-              string:
-                fmt: "%s-secret"
-```
+Remember to create a unique name for each secret.
 {{< /hint >}}
 
-#### Define secret keys
-
-
-A Composition must define the specific secret keys a resource creates with 
-the 
-{{<hover label="conDeet" line="14">}}connectionDetails{{</hover>}} object.
-
-{{<table "table table-sm" >}}
-| Secret Type | Description | 
-| --- | --- | 
-| {{<hover label="conDeet" line="16">}}fromConnectionSecretKey{{</hover>}} | Create a secret key matching the key of a secret generated by the resource. | 
-| {{<hover label="conDeet" line="18">}}fromFieldPath{{</hover>}}  | Create a secret key matching a field path of the resource. |
-| {{<hover label="conDeet" line="20">}}value{{</hover>}}  | Create a secret key with a predefined value. |
-{{< /table >}}
-
-{{<hint "note">}}
-The {{<hover label="conDeet" line="20">}}value{{</hover>}} type must use a
-string value.  
-
-The {{<hover label="conDeet" line="20">}}value{{</hover>}} isn't added to the
-individual resource secret object. The 
-{{<hover label="conDeet" line="20">}}value{{</hover>}} only appears in the 
-combined composite resource secret.
-{{< /hint >}}
-
-```yaml {label="conDeet",copy-lines="none"}
-kind: Composition
-spec:
-  writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key
-      base:
-        # Removed for brevity
-        spec:
-          forProvider:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      connectionDetails:
-        - name: myUsername
-          fromConnectionSecretKey: username
-        - name: myFieldSecret
-          fromFieldPath: spec.forProvider.user
-        - name: myStaticSecret
-          value: "docs.crossplane.io"
-```
-
-The
-{{<hover label="conDeet" line="14">}}connectionDetails{{</hover>}} 
-in a resource can reference a secret from a resource with
-{{<hover label="conDeet" line="16">}}fromConnectionSecretKey{{</hover>}},  
-from another field in the resource with
-{{<hover label="conDeet" line="18">}}fromFieldPath{{</hover>}}  
-or a statically defined value with 
-{{<hover label="conDeet" line="20">}}value{{</hover>}}.
-
-Crossplane sets the secret key to the 
-{{<hover label="conDeet" line="15">}}name{{</hover>}} value. 
-
-Describe the secret to view the secret keys inside the secret object.
-
-{{<hint "tip" >}}
-If more than one resource generates secrets with the same secret key name,
-Crossplane only saves one value. 
-
-Use a custom {{<hover label="conDeet" line="15">}}name{{</hover>}} to create
-unique secret keys.
-{{< /hint >}}
-
-{{<hint "important">}}
-Crossplane only adds connection details listed in the 
-{{<hover label="conDeet" line="16">}}connectionDetails{{</hover>}} 
-to the combined secret object.  
-Any connection secrets in a managed resource, not defined in the 
-{{<hover label="conDeet" line="16">}}connectionDetails{{</hover>}} 
-aren't added to the combined secret object.   
-{{< /hint >}}
-
-
-```shell {copy-lines="1"}
-kubectl describe secret
-Name:         my-access-key-secret
-Namespace:    default
-Labels:       <none>
-Annotations:  <none>
-
-Type:  connection.crossplane.io/v1alpha1
-
-Data
-====
-myUsername:      20 bytes
-myFieldSecret:   24 bytes
-myStaticSecret:  18 bytes
-```
-
-{{<hint "note" >}}
-The CompositeResourceDefinition can also limit which keys Crossplane stores from
-the composite resources.  
-By default an XRD writes all secret keys listed in the composed resources 
-`connectionDetails` to the combined secret object.
-
-Read the 
-[CompositeResourceDefinition documentation]({{<ref "composite-resource-definitions#manage-connection-secrets">}}) 
-for more information on restricting secret keys.
-{{< /hint >}}
-
-For more information on connection secrets read the 
-[Connection Secrets knowledge base article]({{<ref "connection-details">}}).
-
-{{<hint "warning">}}
-You can't change the 
-{{<hover label="conDeet" line="16">}}connectionDetails{{</hover>}} 
-of a Composition.  
-You must delete and
-recreate the Composition to change the 
-{{<hover label="conDeet" line="16">}}connectionDetails{{</hover>}} .
-{{</hint >}}
-
-
-#### Save connection details to an external secret store
+#### External secret stores
 
 Crossplane 
 [External Secret Stores]({{<ref "../guides/vault-as-secret-store" >}}) 
@@ -984,21 +398,13 @@ They're not recommended for production use. Crossplane disables External Secret
 Stores by default.
 {{< /hint >}}
 
-Use 
-{{<hover label="gcp-storeconfig"
-line="11">}}publishConnectionDetailsWithStoreConfigRef{{</hover>}}
-in place of 
-`writeConnectionSecretsToNamespace` to define the 
-{{<hover label="gcp-storeconfig" line="2">}}StoreConfig{{</hover>}} 
-to save connection details to. 
+Use `publishConnectionDetailsWithStoreConfigRef` in place of
+`writeConnectionSecretsToNamespace` to define the `StoreConfig` to save
+connection details to. 
 
-For example, using a 
-{{<hover label="gcp-storeconfig" line="2">}}StoreConfig{{</hover>}} with the 
-{{<hover label="gcp-storeconfig" line="4">}}name{{</hover>}} "vault," 
-use 
-{{<hover label="gcp-storeconfig" line="12">}}publishConnectionDetailsWithStoreConfigRef.name{{</hover>}}
-matching the {{<hover label="gcp-storeconfig" line="4">}}StoreConfig.name{{</hover>}}, 
-in this example, "vault."
+For example, using a `StoreConfig` with the `name` "vault," use
+`publishConnectionDetailsWithStoreConfigRef.name` matching the
+`StoreConfig.name`, in this example, "vault."
 
 
 ```yaml {label="gcp-storeconfig",copy-lines="none"}
@@ -1014,281 +420,182 @@ kind: Composition
 spec:
   publishConnectionDetailsWithStoreConfigRef: 
     name: vault
-  resources:
   # Removed for brevity
 ```
 
-For more details read the [External Secret Stores]({{<ref "../guides/vault-as-secret-store" >}}) 
+For more details read the
+[External Secret Stores]({{<ref "../guides/vault-as-secret-store" >}}) 
 integration guide.
 
-### Resource readiness checks
-
-By default Crossplane considers a Composite Resource or Claim as `READY` when
-the status of all created resource are `Type: Ready` and `Status: True`
+## Test a composition
 
-Some resources, for example, a ProviderConfig, don't have a Kubernetes status
-and are never considered `Ready`.
+You can preview the output of any composition using the Crossplane CLI. You
+don't need a Crossplane control plane to do this. The Crossplane CLI uses Docker
+Engine to run functions.
 
-Custom readiness checks allow Compositions to define what custom conditions
-to meet for a resource to be `Ready`.
-
-{{< hint "tip" >}}
-Use multiple readiness checks if a resource must meet multiple conditions for it
-to be `Ready`.
+{{<hint "important">}}
+The `crossplane render` command only supports composition functions. It doesn't
+support `mode: Resources` Compositions.
 {{< /hint >}}
 
-<!-- vale Google.WordList = NO -->
-Define a custom readiness check with the 
-{{<hover label="check" line="10" >}}readinessChecks{{</hover>}} field on a 
-resource.
-<!-- vale Google.WordList = YES -->
-
-Checks have a 
-{{<hover label="check" line="11" >}}type{{</hover>}} defining how to match the
-resource and a {{<hover label="check" line="12" >}}fieldPath{{</hover>}} of
-which field in the resource to compare.
-
-```yaml {label="check",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: <match type>
-          fieldPath: <resource field>
-```
-
-Compositions support matching resource fields by:
- * [string match](#match-a-string)
- * [integer match](#match-an-integer)
- * [non-empty match](#match-that-a-field-exists)
- * [always ready](#always-consider-a-resource-ready)
- * [condition match](#match-a-condition)
- * [boolean match](#match-a-boolean)
-
-#### Match a string
-
-{{<hover label="matchstring" line="11">}}MatchString{{</hover>}} considers the composed resource to be ready when the value of a
-field in that resource matches a specified string.
-
-{{<hint "note" >}}
-<!-- vale Google.WordList = NO -->
-Crossplane only supports exact string matches. Substrings and regular
-expressions aren't supported in a readiness check.
-<!-- vale Google.WordList = YES -->
-{{</hint >}}
+{{<hint "tip">}}
+See the [Crossplane CLI docs]({{<ref "../cli">}}) to
+learn how to install and use the Crossplane CLI.
+{{< /hint >}}
 
+{{<hint "important">}}
+Running `crossplane render` requires [Docker](https://www.docker.com).
+{{< /hint >}}
 
-For example, matching the string 
-{{<hover label="matchstring" line="13">}}Online{{</hover>}}
-in the resource's 
-{{<hover label="matchstring" line="12">}}status.atProvider.state{{</hover>}}
-field. 
+Provide a composite resource, composition and composition functions to render
+the output locally. 
 
-```yaml {label="matchstring",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: MatchString
-          fieldPath: status.atProvider.state
-          matchString: "Online"
+```shell
+crossplane render xr.yaml composition.yaml functions.yaml
 ```
 
-#### Match an integer
-
-{{<hover label="matchint" line="11">}}MatchInteger{{</hover>}} considers the composed resource to be ready when the value of a
-field in that resource matches a specified integer.
-
-{{<hint "note" >}}
-<!-- vale Google.WordList = NO -->
-Crossplane doesn't support matching `0`. 
-<!-- vale Google.WordList = YES -->
-{{</hint >}}
-
-For example, matching the number
-{{<hover label="matchint" line="13">}}4{{</hover>}}
-in the resource's 
-{{<hover label="matchint" line="12">}}status.atProvider.state{{</hover>}}
-field. 
+`crossplane render` prints resources as YAML to stdout. It prints the
+composite resource first, followed by the resources the composition functions
+created.
 
-```yaml {label="matchint",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
+```yaml
+---
+apiVersion: example.crossplane.io/v1
+kind: XBucket
+metadata:
+  name: example-render
+---
+apiVersion: s3.aws.upbound.io/v1beta1
+kind: Bucket
+metadata:
+  annotations:
+    crossplane.io/composition-resource-name: storage-bucket
+  generateName: example-render-
+  labels:
+    crossplane.io/composite: example-render
+  ownerReferences:
+  - apiVersion: example.crossplane.io/v1
+    blockOwnerDeletion: true
+    controller: true
+    kind: XBucket
+    name: example-render
+    uid: ""
 spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: MatchInteger
-          fieldPath: status.atProvider.state
-          matchInteger: 4
+  forProvider:
+    region: us-east-2
 ```
 
-#### Match that a field exists
-{{<hover label="NonEmpty" line="11">}}NonEmpty{{</hover>}} considers the 
-composed resource to be ready when a field exists with a value. 
+{{<expand "The xr.yaml, composition.yaml and function.yaml files used in the example">}}
 
-{{<hint "note" >}}
-<!-- vale Google.WordList = NO -->
-Crossplane considers a value of `0` or an empty string as empty.
-{{</hint >}}
+You can recreate the output below by running `crossplane render` with
+these files.
 
-For example, to check that a resource's 
-{{<hover label="NonEmpty" line="12">}}status.atProvider.state{{</hover>}}
-field isn't empty. 
-<!-- vale Google.WordList = YES -->
+The `xr.yaml` file contains the composite resource to render:
 
-```yaml {label="NonEmpty",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
+```yaml
+apiVersion: example.crossplane.io/v1
+kind: XBucket
+metadata:
+  name: example-render
 spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: NonEmpty
-          fieldPath: status.atProvider.state
+  bucketRegion: us-east-2
 ```
 
-{{<hint "tip" >}}
-Checking {{<hover label="NonEmpty" line="11">}}NonEmpty{{</hover>}} doesn't
-require setting any other fields.
-{{< /hint >}} 
-
-#### Always consider a resource ready
-{{<hover label="none" line="11">}}None{{</hover>}} considers the 
-composed resource to be ready as soon as it's created. Crossplane doesn't wait
-for any other conditions before declaring the resource ready. 
+The `composition.yaml` file contains the Composition to use to render the
+composite resource:
 
-For example, consider 
-{{<hover label="none" line="7">}}my-resource{{</hover>}}
-ready as soon as it's created.
-
-
-```yaml {label="none",copy-lines="none"}
+```yaml
 apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
-# Removed for Brevity
+metadata:
+  name: example-render
 spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: None
+  compositeTypeRef:
+    apiVersion: example.crossplane.io/v1
+    kind: XBucket
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: storage-bucket
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+        patches:
+        - type: FromCompositeFieldPath
+          fromFieldPath: spec.bucketRegion
+          toFieldPath: spec.forProvider.region
 ```
 
-#### Match a condition
-{{<hover label="condition" line="11">}}Condition{{</hover>}} considers the composed
-resource to be ready when it finds the expected condition type, with the
-expected status for it in its `status.conditions`.
-
-For example, consider 
-{{<hover label="condition" line="7">}}my-resource{{</hover>}}, which is
-ready if there is a condition of type 
-{{<hover label="condition" line="13">}}MyType{{</hover>}} with a status of
-{{<hover label="condition" line="14">}}Success{{</hover>}}.
+The `functions.yaml` file contains the Functions the Composition references in
+its pipeline steps:
 
-```yaml {label="condition",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
+```yaml
+---
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
 spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: MatchCondition
-          matchCondition:
-            type: MyType
-            status: Success
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
 ```
+{{</expand>}}
 
-#### Match a boolean
+The Crossplane CLI uses Docker Engine to run functions. You can change how the
+Crossplane CLI runs a function by adding an annotation in `functions.yaml`. Add
+the `render.crossplane.io/runtime` annotation to a Function to change how it's
+run.
 
-Two types of checks exist for matching boolean fields:
- * `MatchTrue`
- * `MatchFalse`
+`crossplane render` supports two `render.crossplane.io/runtime` values:
 
-`MatchTrue` considers the composed resource to be ready when the value of a 
-field inside that resource is `true`.
+* `Docker` (the default) connects to Docker Engine. It uses Docker to pull and
+  run a function runtime.
+* `Development` connects to a function runtime you have run manually.
 
-`MatchFalse` considers the composed resource to be ready when the value of a 
-field inside that resource is `false`.
+When you use the {{<hover label="development" line="6">}}Development{{</hover>}}
+runtime the Crossplane CLI ignores the Function's {{<hover label="development"
+line="8">}}package{{</hover>}}. Instead it expects you to make sure the function
+is listening on localhost port 9443. The function must be listening without gRPC
+transport security. Most function SDKs let you run a function with the
+`--insecure` flag to disable transport security. For example you can run a Go
+function locally using `go run . --insecure`.
 
-For example, consider 
-{{<hover label="matchTrue" line="7">}}my-resource{{</hover>}}, which is
-ready if 
-{{<hover label="matchTrue" line="12">}} status.atProvider.manifest.status.ready{{</hover>}}
-is {{<hover label="matchTrue" line="11">}}true{{</hover>}}.
-
-```yaml {label="matchTrue",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: MatchTrue
-          fieldPath: status.atProvider.manifest.status.ready
-```
-{{<hint "tip" >}}
-Checking {{<hover label="matchTrue" line="11">}}MatchTrue{{</hover>}} doesn't
-require setting any other fields.
-{{< /hint >}} 
-
-`MatchFalse` matches fields that express readiness with the value `false`.
-
-For example, consider 
-{{<hover label="matchFalse" line="7">}}my-resource{{</hover>}}, is
-ready if 
-{{<hover label="matchFalse" line="12">}} status.atProvider.manifest.status.pending{{</hover>}}
-is {{<hover label="matchFalse" line="11">}}false{{</hover>}}.
-
-```yaml {label="matchFalse",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
+```yaml {label="development"}
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
+  annotations:
+    render.crossplane.io/runtime: Development
 spec:
-  resources:
-  # Removed for Brevity
-    - name: my-resource
-      base:
-        # Removed for brevity
-      readinessChecks:
-        - type: MatchFalse
-          fieldPath: status.atProvider.manifest.status.pending
-```
-
-{{<hint "tip" >}}
-Checking {{<hover label="matchFalse" line="11">}}MatchFalse{{</hover>}} doesn't
-require setting any other fields.
-{{< /hint >}} 
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
+```
+
+{{<hint "tip">}}
+Use the `Development` runtime when you
+[write a composition function](#write-a-composition-function) to test your
+function end-to-end.
+{{</hint>}}
+
+`crossplane render` also supports the following Function annotations. These
+annotations affect how it runs Functions:
+
+* `render.crossplane.io/runtime-docker-cleanup` - When using the `Docker`
+runtime this annotation specifies whether the CLI should stop the function
+container after it calls the function. It supports the values `Stop`, to stop
+the container, and `Orphan`, to leave it running.
+* `render.crossplane.io/runtime-docker-pull-policy` - When using the `Docker`
+  runtime this annotation specifies when the CLI should pull the Function's
+  package. It supports the values `Always`, `Never`, and `IfNotPresent`.
+* `render.crossplane.io/runtime-development-target` - When using the
+  `Development` runtime this annotation tells the CLI to connect to a Function
+  running at the specified target. It uses
+  [gRPC target syntax](https://github.com/grpc/grpc/blob/v1.59.1/doc/naming.md).
 
 ## Verify a Composition
 
@@ -1419,3 +726,261 @@ Crossplane sets a Configuration as unhealthy if there are validation errors.
 View the Configuration details with `kubectl describe configuration` to see the
 specific errors.
 {{< /hint >}}
+
+## Write a composition function
+
+Composition functions let you replace complicated Compositions with code written
+in your programming language of choice. Crossplane has tools, software
+development kits (SDKs) and templates to help you write a function.
+
+
+<!-- vale write-good.Passive = NO -->
+Here's an example of a tiny, hello world function. This example is written in
+[Go](https://go.dev).
+<!-- vale write-good.Passive = YES -->
+
+```go
+func (f *Function) RunFunction(_ context.Context, req *fnv1.RunFunctionRequest) (*fnv1.RunFunctionResponse, error) {
+        rsp := response.To(req, response.DefaultTTL)
+        response.Normal(rsp, "Hello world!")
+        return rsp, nil
+}
+```
+
+Crossplane has [language specific guides]({{<ref "../guides">}}) to writing a
+composition function. Refer to the guide for your preferred language to learn
+how to write a composition function.
+
+When you're writing a composition function it's useful to know how composition
+functions work. Read the next section to learn
+[how composition functions work](#how-composition-functions-work).
+
+## How composition functions work
+
+Each composition function is actually a [gRPC](https://grpc.io) server. gRPC is
+a high performance, open source remote procedure call (RPC) framework. When you
+[install a function](#install-a-composition-function) Crossplane deploys the
+function as a gRPC server. Crossplane encrypts and authenticates all gRPC
+communication.
+
+You don't have to be a gRPC expert to write a function. Crossplane's function
+SDKs setup gRPC for you. It's useful to understand how Crossplane calls your
+function though, and how your function should respond.
+
+```mermaid
+sequenceDiagram
+    User->>+API Server: Create composite resource
+    Crossplane Pod->>+API Server: Observe composite resource
+    Crossplane Pod->>+Function Pod: gRPC RunFunctionRequest
+    Function Pod->>+Crossplane Pod: gRPC RunFunctionResponse
+    loop Extra resources needed?
+      Crossplane Pod->>+API Server: Get Extra resources
+      Crossplane Pod->>+Function Pod: gRPC RunFunctionRequest
+      Function Pod->>+Crossplane Pod: gRPC RunFunctionResponse
+    end
+    Crossplane Pod->>+API Server: Apply desired composed resources
+```
+
+When you create, update, or delete a composite resource that uses composition
+functions Crossplane calls each function in the order they appear in the
+Composition's pipeline. Crossplane calls each function by sending it a gRPC
+RunFunctionRequest. The function must respond with a gRPC RunFunctionResponse.
+
+{{<hint "tip">}}
+You can find detailed schemas for the RunFunctionRequest and RunFunctionResponse
+RPCs in the [Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1beta1).
+{{</hint>}}
+
+When Crossplane calls a function the first time it includes four important
+things in the RunFunctionRequest.
+
+1. The __observed state__ of the composite resource, and any composed resources.
+1. The __desired state__ of the composite resource, and any composed resources.
+1. The function's __input__.
+1. The function pipeline's __context__.
+
+A function's main job is to update the __desired state__ and return it to
+Crossplane. It does this by returning a RunFunctionResponse.
+
+Most composition functions read the observed state of the composite resource,
+and use it to add composed resources to the desired state. This tells Crossplane
+which composed resources it should create or update.
+
+If the function needs __extra resources__ to determine the desired state it can
+request any cluster-scoped resource Crossplane already has access to, either by
+by name or labels through the returned RunFunctionResponse. Crossplane then
+calls the function again including the requested __extra resources__ and the
+__context__ returned by the Function itself alongside the same __input__,
+__observed__ and __desired state__ of the previous RunFunctionRequest. Functions
+can iteratively request __extra resources__ if needed, but to avoid endlessly
+looping Crossplane limits the number of iterations to 5. Crossplane considers
+the function satisfied as soon as the __extra resources__ requests become
+stable, so the Function returns the same exact request two times in a row.
+Crossplane errors if stability isn't reached after 5 iterations.
+
+{{<hint "tip">}}
+<!-- vale write-good.Weasel = NO -->
+<!-- Disable Weasel to say "usually", which is correct in this context. -->
+A _composed_ resource is a resource created by a composite resource. Composed
+resources are usually Crossplane managed resources (MRs), but they can be any
+kind of Crossplane resource. For example a composite resource could also create
+a ProviderConfig, or another kind of composite resource. 
+<!-- vale write-good.Weasel = YES -->
+{{</hint>}}
+
+### Observed state
+
+When you create a composite resource like this one, Crossplane _observes_ it and
+sends it to the composition function as part of the observed state.
+
+```yaml
+apiVersion: example.crossplane.io/v1
+kind: XBucket
+metadata:
+  name: example-render
+spec:
+  bucketRegion: us-east-2
+```
+
+If any composed resources already exist, Crossplane observes them and sends them
+to your function as part of the observed state.
+
+Crossplane also observes the connection details of your composite resource and
+any composed resources. It sends them to your function as part of the observed
+state.
+
+Crossplane observes the composite resource and any composed resources once,
+right before it starts calling the functions in the pipeline. This means that
+Crossplane sends every function in the pipeline the same observed state.
+
+### Desired state
+
+Desired state is the set of the changes the function pipeline wants to make to
+the composite resource and any composed resources. When a function adds composed
+resources to the desired state Crossplane creates them.
+
+A function can change:
+
+* The `status` of the composite resource.
+* The `metadata` and `spec` of any composed resource.
+
+A function can also change the connection details and readiness of the composite
+resource. A function indicates that the composite resource is ready by telling
+Crossplane whether its composed resources are ready. When the function pipeline
+tells Crossplane that all composed resources are ready, Crossplane marks the
+composite resource as ready.
+
+A function can't change:
+
+* The `metadata` or `spec` of the composite resource.
+* The `status` of any composed resource.
+* The connection details of any composed resource.
+
+A pipeline of functions _accumulates_ desired state. This means that each
+function builds upon the desired state of previous functions in the pipeline.
+Crossplane sends a function the desired state accumulated by all previous
+functions in the pipeline. The function adds to or updates the desired state and
+then passes it on. When the last function in the pipeline has run, Crossplane
+applies the desired state it returns.
+
+{{<hint "important">}}
+A function __must__ copy all desired state from its RunFunctionRequest to its
+RunFunctionResponse. If a function adds a resource to its desired state the next
+function must copy it to its desired state. If it doesn't, Crossplane doesn't
+apply the resource. If the resource exists, Crossplane deletes it.
+
+A function can _intentionally_ choose not to copy parts of the desired state.
+For example a function may choose not to copy a desired resource to prevent that
+resource from existing.
+
+Most function SDKs handle copying desired state automatically.
+{{</hint>}}
+
+A function should only add the fields it cares about to the desired state. It
+should add these fields every time Crossplane calls it. If a function adds a
+field to the desired state once, but doesn't add it the next time it's called,
+Crossplane deletes the field. The same is true for composed resources. If a
+function adds a composed resource to the desired state, but doesn't add it the
+next time it's called, Crossplane deletes the composed resource.
+
+{{<hint "tip">}}
+Crossplane uses
+[server side apply](https://kubernetes.io/docs/reference/using-api/server-side-apply/)
+to apply the desired state returned by a function pipeline. In server side apply
+terminology, the desired state is a _fully specified intent_.
+{{</hint>}}
+
+For example, if all a function wants is to make sure an S3 bucket in region
+`us-east-2` exists, it should add this resource to its desired composed
+resources.
+
+```yaml
+apiVersion: s3.aws.upbound.io/v1beta1
+kind: Bucket
+spec:
+  forProvider:
+    region: us-east-2
+```
+
+Even if the Bucket already exists and has other `spec` fields, or a `status`,
+`name`, `labels`, etc the function should omit them. The function should only
+include the fields it has an opinion about. Crossplane takes care of applying
+the fields the function cares about, merging them with the existing Bucket.
+
+{{<hint "tip">}}
+Composition functions don't actually use YAML for desired and observed
+resources. This example uses YAML for illustration purposes only.
+{{</hint>}}
+
+### Function input
+
+If a Composition includes {{<hover label="input" line="14">}}input{{</hover>}}
+Crossplane sends it to the function. Input is a useful way to provide extra
+configuration to a function. Supporting input is optional. Not all functions
+support input.
+
+```yaml {label="input",copy-lines="none"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: example-render
+spec:
+  compositeTypeRef:
+    apiVersion: example.crossplane.io/v1
+    kind: XBucket
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: storage-bucket
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+        patches:
+        - type: FromCompositeFieldPath
+          fromFieldPath: spec.bucketRegion
+          toFieldPath: spec.forProvider.region
+```
+
+{{<hint "important">}}
+Crossplane doesn't validate function input. It's a good idea for a function to
+validate its own input.
+{{</hint>}}
+
+### Function pipeline context
+
+Sometimes two functions in a pipeline want to share information with each other
+that isn't desired state. Functions can use context for this. Any function can
+write to the pipeline context. Crossplane passes the context to all following
+functions. When Crossplane has called all functions it discards the pipeline
+context.
+
+Crossplane can write context too. If you enable the alpha
+[composition environment]({{<ref "environment-configs">}}) feature Crossplane
+writes the environment to the top-level context field
+`apiextensions.crossplane.io/environment`.
\ No newline at end of file
diff --git a/content/master/concepts/connection-details.md b/content/master/concepts/connection-details.md
index 3bf8b8d0..35d76994 100644
--- a/content/master/concepts/connection-details.md
+++ b/content/master/concepts/connection-details.md
@@ -63,74 +63,96 @@ spec:
   compositeTypeRef:
     apiVersion: example.org/v1alpha1
     kind: XSecretTest
-  resources:
-    - name: key
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-            userSelector:
-              matchControllerRef: true
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      connectionDetails:
-        - fromConnectionSecretKey: username
-        - fromConnectionSecretKey: password
-        - fromConnectionSecretKey: attribute.secret
-        - fromConnectionSecretKey: attribute.ses_smtp_password_v4
-      patches:
-        - fromFieldPath: "metadata.uid"
-          toFieldPath: "spec.writeConnectionSecretToRef.name"
-          transforms:
-            - type: string
-              string:
-                fmt: "%s-secret1"
-    - name: user
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: User
-        spec:
-          forProvider: {}
-    - name: user2
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: User
-        metadata:
-          labels:
-            docs.crossplane.io: user
-        spec:
-          forProvider: {}
-    - name: key2
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-            userSelector:
-              matchLabels:
-                docs.crossplane.io: user
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key2
-      connectionDetails:
-        - name: key2-user
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+              userSelector:
+                matchControllerRef: true
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
+        connectionDetails:
+        - name: user
+          type: FromConnectionSecretKey
           fromConnectionSecretKey: username
-        - name: key2-password
+        - name: password
+          type: FromConnectionSecretKey
           fromConnectionSecretKey: password
-        - name: key2-secret
+        - name: key
+          type: FromConnectionSecretKey
           fromConnectionSecretKey: attribute.secret
-        - name: key2-smtp
+        - name: smtp
+          type: FromConnectionSecretKey
           fromConnectionSecretKey: attribute.ses_smtp_password_v4
-      patches:
-        - fromFieldPath: "metadata.uid"
-          toFieldPath: "spec.writeConnectionSecretToRef.name"
-          transforms:
-            - type: string
-              string:
-                fmt: "%s-secret2"
-```
+        patches:
+          - fromFieldPath: "metadata.uid"
+            toFieldPath: "spec.writeConnectionSecretToRef.name"
+            transforms:
+              - type: string
+                string:
+                  type: Format
+                  fmt: "%s-secret1"
+      - name: user
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: User
+          spec:
+            forProvider: {}
+      - name: user2
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: User
+          metadata:
+            labels:
+              docs.crossplane.io: user
+          spec:
+            forProvider: {}
+      - name: key2
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+              userSelector:
+                matchLabels:
+                  docs.crossplane.io: user
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key2
+        connectionDetails:
+          - name: key2-user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
+          - name: key2-password
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: password
+          - name: key2-secret
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: attribute.secret
+          - name: key2-smtp
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: attribute.ses_smtp_password_v4
+        patches:
+          - fromFieldPath: "metadata.uid"
+            toFieldPath: "spec.writeConnectionSecretToRef.name"
+            transforms:
+              - type: string
+                string:
+                  type: Format
+                  fmt: "%s-secret2"
+``  `
 {{</expand >}}
 
 {{<expand "Reference CompositeResourceDefinition" >}}
@@ -284,28 +306,36 @@ apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
   writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key1
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-            # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1-secret
-    - name: key2
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-            # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key2-secret
-    # Removed for brevity
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key1
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+              # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1-secret
+      - name: key2
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+              # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key2-secret
+      # Removed for brevity
 ```
 
 After applying a Claim, view the Kubernetes secrets to see three secret objects
@@ -364,23 +394,39 @@ apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
   writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key
-      base:
-        apiVersion: iam.aws.upbound.io/v1beta1
-        kind: AccessKey
-        spec:
-          forProvider:
-            # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      connectionDetails:
-        - fromConnectionSecretKey: username
-        - fromConnectionSecretKey: password
-        - fromConnectionSecretKey: attribute.secret
-        - fromConnectionSecretKey: attribute.ses_smtp_password_v4
-    # Removed for brevity
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          apiVersion: iam.aws.upbound.io/v1beta1
+          kind: AccessKey
+          spec:
+            forProvider:
+              # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
+        connectionDetails:
+          - name: user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
+          - name: password
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: password
+          - name: key
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: attribute.secret
+          - name: smtp
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: attribute.ses_smtp_password_v4
+      # Removed for brevity
 ```
 
 After applying a Claim the composite resource secret object contains the list of
@@ -418,28 +464,39 @@ apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
   writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key
-      base:
-        kind: AccessKey
-        spec:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      connectionDetails:
-        - fromConnectionSecretKey: username
-    - name: key2
-      base:
-        kind: AccessKey
-        spec:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key2
-      connectionDetails:
-        - name: key2-user
-          fromConnectionSecretKey: username
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          kind: AccessKey
+          spec:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
+        connectionDetails:
+          - name: user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
+      - name: key2
+        base:
+          kind: AccessKey
+          spec:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key2
+        connectionDetails:
+          - name: key2-user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
 ```
 
 The secret object contains both keys, 
@@ -548,28 +605,39 @@ apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
   writeConnectionSecretsToNamespace: other-namespace
-  resources:
-    - name: key
-      base:
-        kind: AccessKey
-        spec:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key1
-      connectionDetails:
-        - fromConnectionSecretKey: username
-    - name: key2
-      base:
-        kind: AccessKey
-        spec:
-          # Removed for brevity
-          writeConnectionSecretToRef:
-            namespace: docs
-            name: key2
-      connectionDetails:
-        - name: key2-user
-          fromConnectionSecretKey: username
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          kind: AccessKey
+          spec:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
+        connectionDetails:
+          - name: user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
+      - name: key2
+        base:
+          kind: AccessKey
+          spec:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key2
+        connectionDetails:
+          - name: key2-user
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
 ```
 
 If a Claim uses a secret, it's stored in the same namespace as the Claim with
diff --git a/content/master/concepts/environment-configs.md b/content/master/concepts/environment-configs.md
index 9010b806..7369218e 100644
--- a/content/master/concepts/environment-configs.md
+++ b/content/master/concepts/environment-configs.md
@@ -3,7 +3,7 @@ title: Environment Configurations
 weight: 75
 state: alpha
 alphaVersion: "1.11"
-description: "Environment Configurations or EnvironmentConfigs are an in-memory datastore used in patching Compositions"
+description: "Environment Configurations or EnvironmentConfigs are an in-memory datastore used in Compositions"
 ---
 
 <!--
@@ -13,9 +13,8 @@ TODO: Add Policies
 
 A Crossplane EnvironmentConfig is a cluster scoped 
 [ConfigMap](https://kubernetes.io/docs/concepts/configuration/configmap/)-like 
-resource used
-by Compositions. Compositions can use the environment to store information from
-individual resources or to apply [patches]({{<ref "patch-and-transform">}}).
+resource used by Compositions. Compositions can use the environment to store
+information from individual resources or to apply patches.
 
 Crossplane supports multiple EnvironmentConfigs, each acting as a unique
 data store. 
@@ -220,7 +219,6 @@ spec:
           - key: my-label-key
             type: FromCompositeFieldPath
             valueFromFieldPath: spec.parameters.deploy
-  resources:
   # Removed for brevity
 ```
 
@@ -347,7 +345,6 @@ spec:
               type: FromCompositeFieldPath
               valueFromFieldPath: spec.parameters.deploy
               fromFieldPathPolicy: Optional
-  resources:
   # Removed for brevity
 ```
 
@@ -386,7 +383,6 @@ spec:
               type: FromCompositeFieldPath
               valueFromFieldPath: spec.parameters.deploy
               fromFieldPathPolicy: Optional
-  resources:
   # Removed for brevity
 ```
 
@@ -397,87 +393,22 @@ Defining the default value _after_ the label always overwrites the label
 value.
 {{< /hint >}}
 
-## Patching with EnvironmentConfigs
+## Use EnvironmentConfigs in a Composition
 
-When Crossplane creates or updates a composite resource, Crossplane 
-merges all the specified EnvironmentConfigs into an in-memory environment.
+When Crossplane creates or updates a composite resource, it merges all the
+specified EnvironmentConfigs into an in-memory environment.
 
-The composite resource can read or write data between the EnvironmentConfig and
-composite resource or between the EnvironmentConfig and individual resources
-defined inside the composite resource. 
+Crossplane sends the merged, in-memory environment to the composition function
+pipeline using the
+[pipeline context]({{<ref "./compositions#function-pipeline-context">}}).
+It writes the environment to the `apiextensions.crossplane.io/environment`
+context key.
+
+Some composition functions can read the environment from the pipeline context
+and use it to compose resources.
 
 {{<hint "tip" >}}
-Read about EnvironmentConfig patch types in the 
-[Patch and Transform]({{<ref "./patch-and-transform">}}) documentation.
+The Patch and Transform function can use the environment to patch composed
+resources. Read about EnvironmentConfig patch types in the
+[Patch and Transform function documentation]({{<ref "../guides/function-patch-and-transform">}}).
 {{< /hint >}}
-
-<!-- these two sections are duplicated in the compositions doc with different header depths --> 
-
-### Patch a composite resource
-To patch the composite resource use
-{{< hover label="xrpatch" line="7">}}patches{{</hover>}} inside of the 
-{{< hover label="xrpatch" line="5">}}environment{{</hover>}}.
-
-Use the 
-{{< hover label="xrpatch" line="5">}}ToCompositeFieldPath{{</hover>}} to copy
-data from the in-memory environment to the composite resource.  
-Use the 
-{{< hover label="xrpatch" line="5">}}FromCompositeFieldPath{{</hover>}} to copy
-data from the composite resource to the in-memory environment.
-
-```yaml {label="xrpatch",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  environment:
-  # Removed for Brevity
-      patches:
-      - type: ToCompositeFieldPath
-        fromFieldPath: tags
-        toFieldPath: metadata.labels[envTag]
-      - type: FromCompositeFieldPath
-        fromFieldPath: metadata.name
-        toFieldPath: newEnvironmentKey
-```
-
-Individual resources can use any data written to the in-memory environment.
-
-### Patch an individual resource
-To patch an individual resource, inside the 
-{{<hover label="envpatch" line="16">}}patches{{</hover>}} of the 
-resource, use 
-{{<hover label="envpatch" line="17">}}ToEnvironmentFieldPath{{</hover>}} to copy
-data from the resource to the in-memory environment.  
-Use {{<hover label="envpatch" line="20">}}FromEnvironmentFieldPath{{</hover>}}
-to copy data to the resource from the in-memory environment.
-
-```yaml {label="envpatch",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for Brevity
-spec:
-  environment:
-  # Removed for Brevity
-  resources:
-  # Removed for Brevity
-    - name: vpc
-      base:
-        apiVersion: ec2.aws.upbound.io/v1beta1
-        kind: VPC
-        spec:
-          forProvider:
-            cidrBlock: 172.16.0.0/16
-      patches:
-        - type: ToEnvironmentFieldPath
-          fromFieldPath: status.atProvider.id
-          toFieldPath: vpcId
-        - type: FromEnvironmentFieldPath
-          fromFieldPath: tags
-          toFieldPath: spec.forProvider.tags
-```
-
-The [Patch and Transform]({{<ref "./patch-and-transform">}}) documentation has
-more information on patching individual resources.
-
-<!-- End duplicated content -->
\ No newline at end of file
diff --git a/content/master/concepts/managed-resources.md b/content/master/concepts/managed-resources.md
index d06ad7fe..21d249be 100644
--- a/content/master/concepts/managed-resources.md
+++ b/content/master/concepts/managed-resources.md
@@ -183,12 +183,6 @@ spec:
 
 Matching by selector is the most flexible matching method. 
 
-{{<hint "note" >}}
-
-The [Compositions]({{<ref "./compositions">}}) section covers the 
-`matchControllerRef` selector.
-{{</hint >}}
-
 Use `matchLabels` to match the labels applied to a resource. For example, this
 Subnet resource only matches VPC resources with the label 
 `my-label: label-value`.
@@ -204,6 +198,100 @@ spec:
         my-label: label-value
 ```
 
+##### Matching by controller reference 
+
+Matching a controller reference ensures that the matching resource is part of
+the same composite resource.
+
+{{<hint "note" >}}
+Learn more about composite resources in the
+[Composite Resources]({{<ref "./composite-resources">}}) section.
+{{</hint >}}
+
+Matching only a controller reference simplifies the matching process without
+requiring labels or more information. 
+
+For example, creating an AWS `InternetGateway` requires a `VPC`.
+
+The `InternetGateway` could match a label, but every VPC created by this
+Composition shares the same label. 
+
+Using `matchControllerRef` matches only the VPC created in the same composite
+resource that created the `InternetGateway`. 
+
+```yaml {label="controller1",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: VPC
+    name: my-vpc
+    spec:
+      forProvider:
+      # Removed for brevity
+- base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: InternetGateway
+    name: my-gateway
+    spec:
+      forProvider:
+        vpcIdSelector:
+          matchControllerRef: true
+```
+
+Resources can match both labels and a controller reference to match a specific
+resource in the larger composite resource. 
+
+For example, this Composition creates two `VPC` resources, but the
+`InternetGateway` must match only one. 
+
+Applying a `label` to the second `VPC` allows the `InternetGateway` to match the
+label `type: internet` and only match objects in the same composite resource
+with `matchControllerRef`.
+
+```yaml {label="controller2",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-first-vpc
+  base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: VPC
+    metadata:
+      labels:
+        type: backend
+    spec:
+      forProvider:
+      # Removed for brevity
+- name: my-second-vpc
+  base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: VPC
+    metadata:
+      labels:
+        type: internet
+    spec:
+      forProvider:
+      # Removed for brevity
+- name: my-gateway
+  base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: InternetGateway
+    spec:
+      forProvider:
+        vpcIdSelector:
+          matchControllerRef: true
+          matchLabels:
+            type: internet
+```
+
+{{<hint "note" >}}
+These examples use Function Patch and Transform. Learn more about functions and
+Compositions in the [Compositions]({{<ref "./compositions">}}) section.
+{{</hint >}}
+
+
 
 #### Immutable fields
 
diff --git a/content/master/concepts/packages.md b/content/master/concepts/packages.md
index bfe13b02..43a8d22e 100644
--- a/content/master/concepts/packages.md
+++ b/content/master/concepts/packages.md
@@ -10,19 +10,19 @@ A _Configuration_ package is an
 [Compositions]({{<ref "./compositions" >}}), 
 [Composite Resource Definitions]({{<ref "./composite-resource-definitions" >}})
 and any required [Providers]({{<ref "./providers">}}) or 
-[Functions]({{<ref "./composition-functions" >}}).
+[Functions]({{<ref "./compositions" >}}).
 
 Configuration packages make your Crossplane configuration fully portable. 
 
 {{<hint "important" >}}
 Crossplane [Providers]({{<ref "./providers">}}) and 
-[Functions]({{<ref "./composition-functions">}}) are also Crossplane packages.  
+[Functions]({{<ref "./compositions">}}) are also Crossplane packages.  
 
 This document describes how to install and manage configuration packages.  
 
 Refer to the 
 [Provider]({{<ref "./providers">}}) and 
-[Composition Functions]({{<ref "./composition-functions">}}) chapters for
+[Composition Functions]({{<ref "./compositions">}}) chapters for
 details on their usage of packages. 
 {{< /hint >}}
 
diff --git a/content/master/concepts/patch-and-transform.md b/content/master/concepts/patch-and-transform.md
deleted file mode 100644
index d0c6051f..00000000
--- a/content/master/concepts/patch-and-transform.md
+++ /dev/null
@@ -1,1726 +0,0 @@
----
-title: Patch and Transforms
-weight: 70
-description: "Crossplane Compositions use patches and transforms to modify inputs from claims and composite resources before creating managed resources"
----
-
-Crossplane Compositions allow for "patch and transform" operations. With patches
-a Composition can apply changes to the resources defined by the Composition. 
-
-When users create Claims, Crossplane passes the settings in the Claim to
-the associated composite resource. Patches can use these settings to change the
-associated composite resource or managed resources. 
-
-Examples of using patch and transforms include:
- * changing the name of the external resource
- * mapping generic terms like "east" or "west" to specific provider locations
- * appending custom labels or strings to resource fields
-
-
-{{<hint "note" >}}
-<!-- vale alex.Condescending = NO -->
-Crossplane expects patch and transform operations to be simple changes.  
-Use [Composition Functions]({{<ref "./composition-functions">}}) for more
-complex or programmatic modifications.
-<!-- vale  alex.Condescending = YES -->
-{{</hint >}}
-
-
-A Composition [patch](#create-a-patch) is the action of changing a field.  
-A Composition [transform](#transform-a-patch) modifies the values before 
-applying the patch.
-
-## Create a patch
-
-Patches are part of an individual 
-{{<hover label="createComp" line="4">}}resource{{</hover>}} inside a 
-{{<hover label="createComp" line="2">}}Composition{{</hover>}}.
-
-The {{<hover label="createComp" line="8">}}patches{{</hover>}} field takes a
-list of patches to apply to the individual resource. 
-
-Each patch has a {{<hover label="createComp" line="9">}}type{{</hover>}}, which
-defines what kind of patch action Crossplane applies. 
-
-Patches reference fields inside a composite resource or Composition differently
-depending on the patch type, but all patches reference a 
-{{<hover label="createComp" line="10">}}fromFieldPath{{</hover>}} and
-{{<hover label="createComp" line="11">}}toFieldPath{{</hover>}}.
-
-The {{<hover label="createComp" line="10">}}fromFieldPath{{</hover>}} defines
-the patch's input values. 
-The {{<hover label="createComp" line="11">}}toFieldPath{{</hover>}} defines the
-data to change with a patch.
-
-Here is an example patch applied to a resource in a Composition. 
-```yaml {label="createComp",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-spec:
-  resources:
-    - name: my-composed-resource
-      base:
-        # Removed for brevity
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: spec.field1
-          toFieldPath: metadata.labels["patchLabel"]
-```
-
-### Selecting fields
-
-Crossplane selects fields in a composite resource or managed
-resource with
-a subset of 
-[JSONPath selectors](https://kubernetes.io/docs/reference/kubectl/jsonpath/),
-called "field selectors."
-
-Field selectors can select any field in a composite resource or managed resource 
-object, including the `metadata`, `spec` or `status` fields. 
-
-Field selectors can be a string matching a field name or an array index, in
-brackets. Field names may use a `.` character to select child elements.
-
-#### Example field selectors
-Here are some example selectors from a composite resource object.
-{{<table "table" >}}
-| Selector | Selected element | 
-| --- | --- |
-| `kind` | {{<hover label="select" line="3">}}kind{{</hover>}} |
-| `metadata.labels['crossplane.io/claim-name']` | {{<hover label="select" line="7">}}my-example-claim{{</hover>}} |
-| `spec.desiredRegion` | {{<hover label="select" line="11">}}eu-north-1{{</hover>}} |
-| `spec.resourceRefs[0].name` | {{<hover label="select" line="16">}}my-example-claim-978mh-r6z64{{</hover>}} |
-{{</table >}}
-
-```yaml {label="select",copy-lines="none"}
-$ kubectl get composite -o yaml
-apiVersion: example.org/v1alpha1
-kind: xExample
-metadata:
-  # Removed for brevity
-  labels:
-    crossplane.io/claim-name: my-example-claim
-    crossplane.io/claim-namespace: default
-    crossplane.io/composite: my-example-claim-978mh
-spec:
-  desiredRegion: eu-north-1
-  field1: field1-text
-  resourceRefs:
-  - apiVersion: s3.aws.upbound.io/v1beta1
-    kind: Bucket
-    name: my-example-claim-978mh-r6z64
-  - apiVersion: s3.aws.upbound.io/v1beta1
-    kind: Bucket
-    name: my-example-claim-978mh-cnlhj
-  - apiVersion: s3.aws.upbound.io/v1beta1
-    kind: Bucket
-    name: my-example-claim-978mh-rv5nm
-  # Removed for brevity
-```
-
-## Reuse a patch
-
-A Composition can reuse a patch object on multiple resources with a 
-PatchSet.
-
-To create a PatchSet, define a 
-{{<hover label="patchset" line="5">}}PatchSets{{</hover>}} object inside the 
-Composition's
-{{<hover label="patchset" line="4">}}spec{{</hover>}}. 
-
-Each patch inside a PatchSet has a 
-{{<hover label="patchset" line="6">}}name{{</hover>}} and a list of
-{{<hover label="patchset" line="7">}}patches{{</hover>}}.  
-
-{{<hint "note" >}}
-For multiple PatchSets only use a single 
-{{<hover label="patchset" line="5">}}PatchSets{{</hover>}} object.  
-
-Identify each unique PatchSet with a unique 
-{{<hover label="patchset" line="6">}}name{{</hover>}}.
-{{</hint >}}
-
-Apply the PatchSet to a resource with a patch
-{{<hover label="patchset" line="16">}}type: PatchSet{{</hover>}}.  
-Set the 
-{{<hover label="patchset" line="17">}}patchSetName{{</hover>}} to the 
-{{<hover label="patchset" line="6">}}name{{</hover>}} of the PatchSet.
-
-```yaml {label="patchset"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-spec:
-  patchSets:
-  - name: my-patchset
-    patches:
-    - type: FromCompositeFieldPath
-      fromFieldPath: spec.desiredRegion
-      toFieldPath: spec.forProvider.region
-  resources:
-    - name: bucket1
-      base:
-        # Removed for brevity
-      patches:
-        - type: PatchSet
-          patchSetName: my-patchset
-    - name: bucket2
-      base:
-        # Removed for brevity
-      patches:
-        - type: PatchSet
-          patchSetName: my-patchset  
-```
-
-{{<hint "important" >}}
-A PatchSet can't contain other PatchSets.  
-
-Crossplane ignores any [transforms](#transform-a-patch) or
-[policies](#patch-policies) in a PatchSet.
-{{< /hint >}}
-
-## Patching between resources
-
-Compositions can't directly patch between resources in the same Composition.  
-For example, generating a network resource and patching the resource name to 
-a compute resource. 
-
-{{<hint "important">}}
-The [ToEnvironmentFieldPath](#toenvironmentfieldpath) patch can't read from a
-`Status` field.
-{{< /hint >}}
-
-A resource can patch to a user-defined 
-{{<hover label="xrdPatch" line="13">}}Status{{</hover>}}
-field in the composite resource.
-
-A resource can then read from that 
-{{<hover label="xrdPatch" line="13">}}Status{{</hover>}} 
-field to patch a field. 
-
-First, define a custom
-{{<hover label="xrdPatch" line="13">}}Status{{</hover>}}
-in the Composite Resource Definition and a custom field, for example
-{{<hover label="xrdPatch" line="16">}}secondResource{{</hover>}}
-
-```yaml {label="xrdPatch",copy-lines="13-17"}
-kind: CompositeResourceDefinition
-# Removed for brevity.
-spec:
-  # Removed for brevity.
-  versions:
-  - name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        type: object
-        properties:
-          spec:
-            # Removed for brevity.
-          status:
-              type: object
-              properties:
-                secondResource:
-                  type: string
-```
-
-Inside the Composition the resource with the source data uses a
-{{<hover label="patchBetween" line="10">}}ToCompositeFieldPath{{</hover>}}
-patch to write data to the 
-{{<hover label="patchBetween" line="12">}}status.secondResource{{</hover>}} 
-field in the composite resource. 
-
-The destination resource uses a 
-{{<hover label="patchBetween" line="19">}}FromCompositeFieldPath{{</hover>}}
-patch to read data from the composite resource
-{{<hover label="patchBetween" line="20">}}status.secondResource{{</hover>}} 
-field in the composite resource and write it to a label named 
-{{<hover label="patchBetween" line="21">}}secondResource{{</hover>}} in the
-managed resource.
-
-```yaml {label="patchBetween",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        # Removed for brevity
-      patches:
-        - type: ToCompositeFieldPath
-          fromFieldPath: metadata.name
-          toFieldPath: status.secondResource
-    - name: bucket2
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        # Removed for brevity
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: status.secondResource
-          toFieldPath: metadata.labels['secondResource']
-```
-
-Describe the composite resource to view the 
-{{<hover label="descCompPatch" line="5">}}resources{{</hover>}} and the 
-{{<hover label="descCompPatch" line="11">}}status.secondResource{{</hover>}}
-value. 
-
-```yaml {label="descCompPatch",copy-lines="none"}
-$ kubectl describe composite
-Name:         my-example-claim-jp7rx
-Spec:
-  # Removed for brevity
-  Resource Refs:
-    Name:         my-example-claim-jp7rx-gfg4m
-    # Removed for brevity
-    Name:         my-example-claim-jp7rx-fttpj
-Status:
-  # Removed for brevity
-  Second Resource:         my-example-claim-jp7rx-gfg4m
-```
-
-Describe the destination managed resource to see the label 
-{{<hover label="bucketlabel" line="5">}}secondResource{{</hover>}}.
-
-```yaml {label="bucketlabel",copy-lines="none"}
-$ kubectl describe bucket
-kubectl describe bucket my-example-claim-jp7rx-fttpj
-Name:         my-example-claim-jp7rx-fttpj
-Labels:       crossplane.io/composite=my-example-claim-jp7rx
-              secondResource=my-example-claim-jp7rx-gfg4m
-```
-
-## Types of patches
-Crossplane supports multiple patch types, each using a different source for data
-and applying the patch to a different location. 
-
-{{<hint "important" >}}
-
-This section describes patches applied to individual resources inside a
-Composition.  
-
-For information about applying patches to an entire composite resource with a
-Composition's `environment.patches` read the 
-[Environment Configurations]({{<ref "environment-configs" >}}) documentation.
-
-{{< /hint >}}
-
-Summary of Crossplane patches
-{{< table "table table-hover" >}}
-| Patch Type | Data Source | Data Destination | 
-| ---  | --- | --- | 
-| [FromCompositeFieldPath](#fromcompositefieldpath) | A field in the composite resource. | A field in the patched managed resource. | 
-| [ToCompositeFieldPath](#tocompositefieldpath) | A field in the patched managed resource. | A field in the composite resource. |  
-| [CombineFromComposite](#combinefromcomposite) | Multiple fields in the composite resource. | A field in the patched managed resource. | 
-| [CombineToComposite](#combinetocomposite) | Multiple fields in the patched managed resource. | A field in the composite resource. | 
-| [FromEnvironmentFieldPath](#fromenvironmentfieldpath) | Data in the in-memory EnvironmentConfig Environment | A field in the patched managed resource. | 
-| [ToEnvironmentFieldPath](#toenvironmentfieldpath) | A field in the patched managed resource. | The in-memory EnvironmentConfig Environment. | 
-| [CombineFromEnvironment](#combinefromenvironment) | Multiple fields in the in-memory EnvironmentConfig Environment. | A field in the patched managed resource. | 
-| [CombineToEnvironment](#combinetoenvironment) | Multiple fields in the patched managed resource. | A field in the in-memory EnvironmentConfig Environment. | 
-{{< /table >}}
-
-{{<hint "note" >}}
-All the following examples use the same set of Compositions, 
-CompositeResourceDefinitions, Claims and EnvironmentConfigs.  
-Only the applied patches change between
-examples. 
-
-All examples rely on Upbound
-[provider-aws-s3](https://marketplace.upbound.io/providers/upbound/provider-aws-s3/)
-to create resources.
-
-{{< expand "Reference Composition" >}}
-```yaml {copy-lines="all"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-metadata:
-  name: example-composition
-spec:
-  compositeTypeRef:
-    apiVersion: example.org/v1alpha1
-    kind: xExample
-  environment:
-    environmentConfigs:
-    - ref:
-        name: example-environment
-  resources:
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-    - name: bucket2
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-```
-{{< /expand >}}
-
-{{<expand "Reference CompositeResourceDefinition" >}}
-```yaml {copy-lines="all"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: CompositeResourceDefinition
-metadata:
-  name: xexamples.example.org
-spec:
-  group: example.org
-  names:
-    kind: xExample
-    plural: xexamples
-  claimNames:
-    kind: ExampleClaim
-    plural: exampleclaims
-  versions:
-  - name: v1alpha1
-    served: true
-    referenceable: true
-    schema:
-      openAPIV3Schema:
-        type: object
-        properties:
-          spec:
-            type: object
-            properties:
-              field1:
-                type: string
-              field2:
-                type: string
-              field3: 
-                type: string
-              desiredRegion: 
-                type: string
-              boolField:
-                type: boolean
-              numberField:
-                type: integer
-          status:
-              type: object
-              properties:
-                url:
-                  type: string
-```
-{{< /expand >}}
-
-
-{{< expand "Reference Claim" >}}
-```yaml {copy-lines="all"}
-apiVersion: example.org/v1alpha1
-kind: ExampleClaim
-metadata:
-  name: my-example-claim
-spec:
-  field1: "field1-text"
-  field2: "field2-text"
-  desiredRegion: "eu-north-1"
-  boolField: false
-  numberField: 10
-```
-{{< /expand >}}
-
-{{< expand "Reference EnvironmentConfig" >}}
-```yaml {copy-lines="all"}
-apiVersion: apiextensions.crossplane.io/v1alpha1
-kind: EnvironmentConfig
-metadata:
-  name: example-environment
-data:
-  locations:
-    us: us-east-2
-    eu: eu-north-1
-  key1: value1
-  key2: value2
-
-```
-{{< /expand >}}
-{{< /hint >}}
-
-<!-- vale Google.Headings = NO -->
-### FromCompositeFieldPath
-<!-- vale Google.Headings = YES -->
-
-The 
-{{<hover label="fromComposite" line="12">}}FromCompositeFieldPath{{</hover>}}
-patch takes a value in a composite resource and applies it to a field in the 
-managed resource. 
-
-{{< hint "tip" >}}
-Use the 
-{{<hover label="fromComposite" line="12">}}FromCompositeFieldPath{{</hover>}}
-patch to apply options from users in their Claims to settings in managed
-resource `forProvider` settings. 
-{{< /hint >}}
-
-For example, to use the value 
-{{<hover label="fromComposite" line="13">}}desiredRegion{{</hover>}} provided by
-a user in a composite resource to a managed resource's
-{{<hover label="fromComposite" line="10">}}region{{</hover>}}. 
-
-The {{<hover label="fromComposite" line="13">}}fromFieldPath{{</hover>}} value
-is a field in the composite resource. 
-
-The {{<hover label="fromComposite" line="14">}}toFieldPath{{</hover>}} value is
-the field in the managed resource to change. 
-
-```yaml {label="fromComposite",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: spec.desiredRegion
-          toFieldPath: spec.forProvider.region
-```
-
-View the managed resource to see the updated 
-{{<hover label="fromCompMR" line="6">}}region{{</hover>}}
-
-```yaml {label="fromCompMR",copy-lines="1"}
-$ kubectl describe bucket
-Name:         my-example-claim-qlr68-29nqf
-# Removed for brevity
-Spec:
-  For Provider:
-    Region:  eu-north-1
-```
-
-<!-- vale Google.Headings = NO -->
-### ToCompositeFieldPath
-<!-- vale Google.Headings = YES -->
-
-The 
-{{<hover label="toComposite" line="12">}}ToCompositeFieldPath{{</hover>}} writes 
-data from an individual managed resource to
-the composite resource that created it.
-
-{{< hint "tip" >}}
-Use {{<hover label="toComposite" line="12">}}ToCompositeFieldPath{{</hover>}}
-patches to take data from one managed resource in a Composition and use it in a
-second managed resource in the same Composition. 
-{{< /hint >}}
-
-For example, after Crossplane creates a new managed resource, take the value 
-{{<hover label="toComposite" line="13">}}hostedZoneID{{</hover>}} and apply it
-as a 
-{{<hover label="toComposite" line="14">}}label{{</hover>}} in the composite
-resource.
-
-```yaml {label="toComposite",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: ToCompositeFieldPath
-          fromFieldPath: status.atProvider.hostedZoneId
-          toFieldPath: metadata.labels['ZoneID']
-```
-
-View the created managed resource to see the 
-{{<hover label="toCompMR" line="6">}}Hosted Zone Id{{</hover>}} field.
-```yaml {label="toCompMR",copy-lines="none"}
-$ kubectl describe bucket
-Name:         my-example-claim-p5pxf-5vnp8
-# Removed for brevity
-Status:
-  At Provider:
-    Hosted Zone Id:       Z2O1EMRO9K5GLX
-    # Removed for brevity
-```
-
-Next view the composite resource and confirm the patch applied the 
-{{<hover label="toCompositeXR" line="3">}}label{{</hover>}}
-```yaml {label="toCompositeXR",copy-lines="none"}
-$ kubectl describe composite
-Name:         my-example-claim-p5pxf
-Labels:       ZoneID=Z2O1EMRO9K5GLX
-```
-
-{{<hint "important">}}
-Crossplane doesn't apply the patch to the composite resource until the next
-reconcile loop, after creating the managed resource. This creates a delay
-between a managed resource being Ready and applying the patch.
-{{< /hint >}}
-
-
-<!-- vale Google.Headings = NO -->
-### CombineFromComposite
-<!-- vale Google.Headings = YES -->
-
-The 
-{{<hover label="combineFromComp" line="12">}}CombineFromComposite{{</hover>}}
-patch takes values from the composite resource, combines them and applies them
-to the managed resource. 
-
-{{< hint "tip" >}}
-Use the 
-{{<hover label="combineFromComp" line="12">}}CombineFromComposite{{</hover>}}
-patch to create complex strings, like security policies and apply them to
-a managed resource. 
-{{< /hint >}}
-
-For example, use the Claim value 
-{{<hover label="combineFromComp" line="15">}}desiredRegion{{</hover>}} and 
-{{<hover label="combineFromComp" line="16">}}field2{{</hover>}} to generate the
-managed resource's
-{{<hover label="combineFromComp" line="20">}}name{{</hover>}}
-
-The 
-{{<hover label="combineFromComp" line="12">}}CombineFromComposite{{</hover>}}
-patch only supports the 
-{{<hover label="combineFromComp" line="13">}}combine{{</hover>}} option. 
-
-The {{<hover label="combineFromComp" line="14">}}variables{{</hover>}} are the
-list of 
-{{<hover label="combineFromComp" line="15">}}fromFieldPath{{</hover>}} values
-from the composite resource to combine. 
-
-The only supported 
-{{<hover label="combineFromComp" line="17">}}strategy{{</hover>}} is 
-{{<hover label="combineFromComp" line="17">}}strategy: string{{</hover>}}.
-
-Optionally you can apply a 
-{{<hover label="combineFromComp" line="19">}}string.fmt{{</hover>}}, based on 
-[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
-strings.
-
-The {{<hover label="combineFromComp" line="20">}}toFieldPath{{</hover>}} is the
-field in the managed resource to apply the new string to. 
-
-```yaml {label="combineFromComp",copy-lines="11-20"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: CombineFromComposite
-          combine:
-            variables:
-              - fromFieldPath: spec.desiredRegion
-              - fromFieldPath: spec.field2
-            strategy: string
-            string:
-              fmt: "my-resource-%s-%s"
-          toFieldPath: metadata.name
-```
-
-Describe the managed resource to see the applied patch.
-
-```yaml {label="describeCombineFromComp",copy-lines="none"}
-$ kubectl describe bucket
-Name:         my-resource-eu-north-1-field2-text
-```
-
-<!-- vale Google.Headings = NO -->
-### CombineToComposite
-<!-- vale Google.Headings = YES -->
-
-The 
-{{<hover label="combineToComposite" line="12">}}CombineToComposite{{</hover>}}
-patch takes values from the managed resource, combines them and applies them
-to the composite resource. 
-
-{{<hint "tip" >}}
-Use {{<hover label="combineToComposite" line="12">}}CombineToComposite{{</hover>}}
-patches to create a single field like a URL from multiple fields in a managed
-resource. 
-{{< /hint >}}
-
-For example, use the managed resource 
-{{<hover label="combineToComposite" line="15">}}name{{</hover>}} and 
-{{<hover label="combineToComposite" line="16">}}region{{</hover>}} to generate a
-custom 
-{{<hover label="combineToComposite" line="20">}}url{{</hover>}}
-field. 
-
-{{< hint "important" >}}
-Writing custom fields in the Status field of a composite resource requires
-defining the custom fields in the CompositeResourceDefinition first. 
-
-{{< /hint >}}
-
-The 
-{{<hover label="combineToComposite" line="12">}}CombineToComposite{{</hover>}}
-patch only supports the 
-{{<hover label="combineToComposite" line="13">}}combine{{</hover>}} option. 
-
-The {{<hover label="combineToComposite" line="14">}}variables{{</hover>}} are the
-list of 
-{{<hover label="combineToComposite" line="15">}}fromFieldPath{{</hover>}} 
-the managed resource to combine. 
-
-The only supported 
-{{<hover label="combineToComposite" line="17">}}strategy{{</hover>}} is 
-{{<hover label="combineToComposite" line="17">}}strategy: string{{</hover>}}.
-
-Optionally you can apply a 
-{{<hover label="combineToComposite" line="19">}}string.fmt{{</hover>}}, based on 
-[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
-strings.
-
-The {{<hover label="combineToComposite" line="20">}}toFieldPath{{</hover>}} is the
-field in the composite resource to apply the new string to. 
-
-```yaml {label="combineToComposite",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: CombineToComposite
-          combine:
-            variables:
-              - fromFieldPath: metadata.name
-              - fromFieldPath: spec.forProvider.region
-            strategy: string
-            string:
-              fmt: "https://%s.%s.com"
-          toFieldPath: status.url
-```
-
-View the composite resource to verify the applied patch.
-
-```yaml {copy-lines="none"}
-$ kubectl describe composite
-Name:         my-example-claim-bjdjw
-API Version:  example.org/v1alpha1
-Kind:         xExample
-# Removed for brevity
-Status:
-  # Removed for brevity
-  URL:                     https://my-example-claim-bjdjw-r6ncd.us-east-2.com
-```
-
-<!-- vale Google.Headings = NO -->
-### FromEnvironmentFieldPath
-<!-- vale Google.Headings = YES -->
-
-{{<hint "important" >}}
-EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
-
-For more information about using an EnvironmentConfig, read the 
-[EnvironmentConfigs]({{<ref "./environment-configs">}}) documentation.
-{{< /hint >}}
-
-The 
-{{<hover label="fromEnvField" line="12">}}FromEnvironmentFieldPath{{</hover>}}
-patch takes values from the in-memory EnvironmentConfig environment and applies
-them to the managed resource.
-
-{{<hint "tip" >}}
-Use 
-{{<hover label="fromEnvField" line="12">}}FromEnvironmentFieldPath{{</hover>}}
-to apply custom managed resource settings based on the current environment.  
-{{< /hint >}}
-
-For example, use the environment's 
-{{<hover label="fromEnvField" line="13">}}locations.eu{{</hover>}} value and
-apply it as the 
-{{<hover label="fromEnvField" line="14">}}region{{</hover>}}.
-
-```yaml {label="fromEnvField",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-        patches:
-        - type: FromEnvironmentFieldPath
-          fromFieldPath: locations.eu
-          toFieldPath: spec.forProvider.region
-```
-
-Verify managed resource to confirm the applied patch. 
-
-```yaml {copy-lines="none"}
-kubectl describe bucket
-Name:         my-example-claim-8vrvc-xx5sr
-Labels:       crossplane.io/claim-name=my-example-claim
-# Removed for brevity
-Spec:
-  For Provider:
-    Region:  eu-north-1
-  # Removed for brevity
-```
-
-<!-- vale Google.Headings = NO -->
-### ToEnvironmentFieldPath
-<!-- vale Google.Headings = YES -->
-
-{{<hint "important" >}}
-EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
-
-For more information about using an EnvironmentConfig, read the 
-[EnvironmentConfigs]({{<ref "./environment-configs">}}) documentation.
-{{< /hint >}}
-
-The 
-{{<hover label="toEnvField" line="12">}}ToEnvironmentFieldPath{{</hover>}}
-patch takes values the managed resource and applies them to the in-memory 
-EnvironmentConfig environment.
-
-{{<hint "tip" >}}
-Use 
-{{<hover label="toEnvField" line="12">}}ToEnvironmentFieldPath{{</hover>}}
-write data to the environment that any FromEnvironmentFieldPath
-patch can access. 
-{{< /hint >}}
-
-For example, use the desired
-{{<hover label="toEnvField" line="13">}}region{{</hover>}} value and
-apply it as the environment's
-{{<hover label="toEnvField" line="14">}}key1{{</hover>}}.
-
-
-```yaml {label="toEnvField",copy-lines="9-11"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-        patches:
-        - type: ToEnvironmentFieldPath
-          fromFieldPath: spec.forProvider.region
-          toFieldPath: key1
-```
-
-Because the environment is in-memory, there is no command to confirm the patch
-wrote the value to the environment.
-
-
-<!-- vale Google.Headings = NO -->
-### CombineFromEnvironment
-<!-- vale Google.Headings = YES -->
-
-{{<hint "important" >}}
-EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
-
-For more information about using an EnvironmentConfig, read the 
-[EnvironmentConfigs]({{<ref "./environment-configs">}}) documentation.
-{{< /hint >}}
-
-The 
-{{<hover label="combineFromEnv" line="12">}}CombineFromEnvironment{{</hover>}}
-patch combines multiple values from the in-memory EnvironmentConfig environment and applies
-them to the managed resource.
-
-{{<hint "tip" >}}
-Use 
-{{<hover label="combineFromEnv" line="12">}}CombineFromEnvironment{{</hover>}}
-patch to create complex strings, like security policies and apply them to
-a managed resource. 
-{{< /hint >}}
-
-For example, combine multiple fields in the environment to create a unique 
-{{<hover label="combineFromEnv" line="20">}}annotation{{</hover>}}
-. 
-
-The 
-{{<hover label="combineFromEnv" line="12">}}CombineFromEnvironment{{</hover>}}
-patch only supports the 
-{{<hover label="combineFromEnv" line="13">}}combine{{</hover>}} option. 
-
-The only supported 
-{{<hover label="combineFromEnv" line="14">}}strategy{{</hover>}} is 
-{{<hover label="combineFromEnv" line="14">}}strategy: string{{</hover>}}.
-
-The {{<hover label="combineFromEnv" line="15">}}variables{{</hover>}} are the
-list of 
-{{<hover label="combineFromEnv" line="16">}}fromFieldPath{{</hover>}} values
-from the in-memory environment to combine. 
-
-Optionally you can apply a 
-{{<hover label="combineFromEnv" line="19">}}string.fmt{{</hover>}}, based on 
-[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
-strings.
-
-The {{<hover label="combineFromEnv" line="20">}}toFieldPath{{</hover>}} is the
-field in the managed resource to apply the new string to. 
-
-
-```yaml {label="combineFromEnv",copy-lines="11-20"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: CombineFromEnvironment
-          combine:
-            strategy: string
-            variables:
-            - fromFieldPath: key1
-            - fromFieldPath: key2
-            string: 
-              fmt: "%s-%s"
-          toFieldPath: metadata.annotations[EnvironmentPatch]
-```
-
-Describe the managed resource to see new 
-{{<hover label="combineFromEnvDesc" line="4">}}annotation{{</hover>}}.
-
-```yaml {copy-lines="none",label="combineFromEnvDesc"}
-$ kubectl describe bucket
-Name:         my-example-claim-zmxdg-grl6p
-# Removed for brevity
-Annotations:  EnvironmentPatch: value1-value2
-# Removed for brevity
-```
-
-<!-- vale Google.Headings = NO -->
-### CombineToEnvironment
-<!-- vale Google.Headings = YES -->
-
-{{<hint "important" >}}
-EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
-
-For more information about using an EnvironmentConfig, read the 
-[EnvironmentConfigs]({{<ref "./environment-configs">}}) documentation.
-{{< /hint >}}
-
-The 
-{{<hover label="combineToEnv" line="12">}}CombineToEnvironment{{</hover>}}
-patch combines multiple values from the managed resource and applies them to the in-memory EnvironmentConfig environment.
-
-{{<hint "tip" >}}
-Use 
-{{<hover label="combineToEnv" line="12">}}CombineToEnvironment{{</hover>}}
-patch to create complex strings, like security policies to use in other managed resources. 
-{{< /hint >}}
-
-For example, combine multiple fields in the managed resource to create a unique
-string and store it in the environment's
-{{<hover label="combineToEnv" line="20">}}key2{{</hover>}} value. 
-
-The string combines the
-managed resource 
-{{<hover label="combineToEnv" line="16">}}Kind{{</hover>}} and 
-{{<hover label="combineToEnv" line="17">}}region{{</hover>}}.
-
-The 
-{{<hover label="combineToEnv" line="12">}}CombineToEnvironment{{</hover>}}
-patch only supports the 
-{{<hover label="combineToEnv" line="13">}}combine{{</hover>}} option. 
-
-The only supported 
-{{<hover label="combineToEnv" line="14">}}strategy{{</hover>}} is 
-{{<hover label="combineToEnv" line="14">}}strategy: string{{</hover>}}.
-
-The {{<hover label="combineToEnv" line="15">}}variables{{</hover>}} are the
-list of 
-{{<hover label="combineToEnv" line="16">}}fromFieldPath{{</hover>}} 
-values in the managed resource to combine. 
-
-Optionally you can apply a 
-{{<hover label="combineToEnv" line="19">}}string.fmt{{</hover>}}, based on 
-[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
-strings.
-
-The {{<hover label="combineToEnv" line="20">}}toFieldPath{{</hover>}} is the
-key in the environment to write the new string to. 
-
-```yaml {label="combineToEnv",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: CombineToEnvironment
-          combine:
-            strategy: string
-            variables:
-            - fromFieldPath: kind
-            - fromFieldPath: spec.forProvider.region
-            string:
-              fmt: "%s.%s"
-          toFieldPath: key2
-```
-
-Because the environment is in-memory, there is no command to confirm the patch
-wrote the value to the environment.
-
-## Transform a patch
-
-When applying a patch, Crossplane supports modifying the data before applying it
-as a patch. Crossplane calls this a "transform" operation. 
-
-Summary of Crossplane transforms.
-{{< table "table table-hover" >}}
-| Transform Type | Action |
-| ---  | --- |
-| [convert](#convert-transforms) | Converts an input data type to a different type. Also called "casting." | 
-| [map](#map-transforms) | Selects a specific output based on a specific input. | 
-| [match](#match-transform) | Selects a specific output based on a string or regular expression. | 
-| [math](#math-transforms) | Applies a mathematical operation on the input. | 
-| [string](#string-transforms) | Change the input string using [Go string formatting](https://pkg.go.dev/fmt). | 
-{{< /table >}}
-
-Apply a transform directly to an individual patch with the 
-{{<hover label="transform1" line="15">}}transforms{{</hover>}} field. 
-
-A 
-{{<hover label="transform1" line="15">}}transform{{</hover>}} 
-requires a 
-{{<hover label="transform1" line="16">}}type{{</hover>}}, indicating the
-transform action to take. 
-
-The other transform field is the same as the 
-{{<hover label="transform1" line="16">}}type{{</hover>}}, in this example, 
-{{<hover label="transform1" line="17">}}map{{</hover>}}.
-
-The other fields depend on the patch type used. 
-
-This example uses a 
-{{<hover label="transform1" line="16">}}type: map{{</hover>}} transform, taking 
-the input 
-{{<hover label="transform1" line="13">}}spec.desiredRegion{{</hover>}}, matching
-it to either 
-{{<hover label="transform1" line="18">}}us{{</hover>}} or 
-{{<hover label="transform1" line="19">}}eu{{</hover>}} and returning the
-corresponding AWS region for the 
-{{<hover label="transform1" line="14">}}spec.forProvider.region{{</hover>}}
-value. 
-
-```yaml {label="transform1",copy-lines="none"}
-apiVersion: apiextensions.crossplane.io/v1
-kind: Composition
-# Removed for brevity
-    - name: bucket1
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            region: us-east-2
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: spec.desiredRegion
-          toFieldPath: spec.forProvider.region
-          transforms:
-            - type: map
-              map:
-                us: us-east-2
-                eu: eu-north-1
-```
-
-### Convert transforms
-
-The {{<hover label="convert" line="6">}}convert{{</hover>}} transform type 
-changes the input data type to a different data type.
-
-{{< hint "tip" >}}
-Some provider APIs require a field to be a string. Use a 
-{{<hover label="convert" line="7">}}convert{{</hover>}} type to 
-change any boolean or integer fields to strings. 
-{{< /hint >}}
-
-A {{<hover label="convert" line="6">}}convert{{</hover>}} 
-transform requires a {{<hover label="convert" line="8">}}toType{{</hover>}}, 
-defining the output data type. 
-
-```yaml {label="convert",copy-lines="none"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.numberField
-    toFieldPath: metadata.label["numberToString"]
-    transforms:
-      - type: convert
-        convert:
-          toType: string
-```
-
-Supported `toType` values:
-{{< table "table table-sm table-hover" >}}
-| `toType` value | Description | 
-| -- | -- |
-| `bool` | A boolean value of `true` or `false`. | 
-| `float64` | A 64-bit float value. | 
-| `int` | A 32-bit integer value. | 
-| `int64` | A 64-bit integer value. | 
-| `string` | A string value. | 
-| `object` | An object. |
-| `array` | An array. |
-{{< /table >}}
-
-#### Converting strings to booleans
-When converting from a string to a `bool` Crossplane considers the string values  
-`1`, `t`, `T`, `TRUE`, `True` and `true`  
-equal to the boolean value `True`.  
-
-The strings   
-`0`, `f`, `F`, `FALSE`, `False` and `false`   
-are equal to the boolean value `False`. 
-
-#### Converting numbers to booleans
-Crossplane considers the integer `1` and float `1.0` equal to the boolean
-value `True`.  
-Any other integer or float value is `False`.
-
-#### Converting booleans to numbers
-Crossplane converts the boolean value `True` to the integer `1` or float64
-`1.0`.  
-
-The value `False` converts to the integer `0` or float64 `0.0`
-
-#### Converting strings to float64
-When converting from a `string` to a 
-{{<hover label="format" line="3">}}float64{{</hover>}} Crossplane supports 
-an optional  
-{{<hover label="format" line="4">}}format: quantity{{</hover>}} field.
-
-Using {{<hover label="format" line="4">}}format: quantity{{</hover>}} translates 
-size suffixes like `M` for megabyte or `Mi` for megabit into the correct float64
-value. 
-
-{{<hint "note" >}}
-Refer to the [Go language docs](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity) 
-for a full list of supported suffixes.
-{{</hint >}}
-
-Add {{<hover label="format" line="4">}}format: quantity{{</hover>}} to the 
-{{<hover label="format" line="1">}}convert{{</hover>}} object to enable quantity
-suffix support. 
-
-```yaml {label="format",copy-lines="all"}
-- type: convert
-  convert:
-   toType: float64
-   format: quantity
-```
-
-#### Converting strings to objects
-
-Crossplane converts JSON strings to objects.
-
-Add {{<hover label="object" line="4">}}format: json{{</hover>}} to the 
-{{<hover label="object" line="1">}}convert{{</hover>}} object which is
-the only supported string format for this conversion.
-
-```yaml {label="object",copy-lines="all"}
-- type: convert
-  convert:
-   toType: object
-   format: json
-```
-
-{{< hint "tip" >}}
-This conversion is useful for patching keys in an object.
-{{< /hint >}}
-
-The following example adds a tag to a resource with a
-{{<hover label="patch-key" line="8">}}customized key{{</hover>}}:
-
-```yaml {label="patch-key",copy-lines="all"}
-    - type: FromCompositeFieldPath
-      fromFieldPath: spec.clusterName
-      toFieldPath: spec.forProvider.tags
-      transforms:
-      - type: string
-        string:
-          type: Format
-          fmt: '{"kubernetes.io/cluster/%s": "true"}'
-      - type: convert
-        convert:
-          toType: object
-          format: json
-```
-
-#### Converting strings to arrays
-
-Crossplane converts JSON strings to arrays.
-
-Add {{<hover label="array" line="4">}}format: json{{</hover>}} to the 
-{{<hover label="array" line="1">}}convert{{</hover>}} object which is
-the only supported string format for this conversion.
-
-```yaml {label="array",copy-lines="all"}
-- type: convert
-  convert:
-   toType: array
-   format: json
-```
-
-### Map transforms
-The {{<hover label="map" line="6">}}map{{</hover>}} transform type 
-_maps_ an input value to an output value. 
-
-{{< hint "tip" >}}
-The {{<hover label="map" line="6">}}map{{</hover>}} transform is useful for
-translating generic region names like `US` or `EU` to provider specific region
-names. 
-{{< /hint >}}
-
-The {{<hover label="map" line="6">}}map{{</hover>}} transform compares the value
-from the {{<hover label="map" line="3">}}fromFieldPath{{</hover>}} to the
-options listed in the {{<hover label="map" line="6">}}map{{</hover>}}.  
-
-If Crossplane finds the value, Crossplane puts
-the mapped value in the {{<hover label="map" line="4">}}toFieldPath{{</hover>}}.
-
-{{<hint "note" >}}
-Crossplane throws an error for the patch if the value isn't found.
-{{< /hint >}}
-
-{{<hover label="map" line="3">}}spec.field1{{</hover>}} is the string
-{{<hover label="map" line="8">}}"field1-text"{{</hover>}} then Crossplane uses
-the string 
-{{<hover label="map" line="8">}}firstField{{</hover>}} for the 
-{{<hover label="map" line="4">}}annotation{{</hover>}}.  
-
-If
-{{<hover label="map" line="3">}}spec.field1{{</hover>}} is the string
-{{<hover label="map" line="8">}}"field2-text"{{</hover>}} then Crossplane uses
-the string 
-{{<hover label="map" line="8">}}secondField{{</hover>}} for the 
-{{<hover label="map" line="4">}}annotation{{</hover>}}.  
-
-```yaml {label="map",copy-lines="none"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: map
-        map:
-          "field1-text": "firstField"
-          "field2-text": "secondField"
-```
-In this example, the value of 
-{{<hover label="map" line="3">}}spec.field1{{</hover>}} is 
-{{<hover label="comositeMap" line="5">}}field1-text{{</hover>}}.
-
-```yaml {label="comositeMap",copy-lines="none"}
-$ kubectl describe composite
-Name:         my-example-claim-twx7n
-Spec:
-  # Removed for brevity
-  field1:         field1-text
-```
-
-The annotation applied to the managed resource is 
-{{<hover label="mrMap" line="4">}}firstField{{</hover>}}.
-
-```yaml {label="mrMap",copy-lines="none"}
-$ kubectl describe bucket
-Name:         my-example-claim-twx7n-ndb2f
-Annotations:  crossplane.io/composition-resource-name: bucket1
-              myAnnotation: firstField
-# Removed for brevity.
-```
-
-### Match transform
-The {{<hover label="match" line="6">}}match{{</hover>}} transform is like the
-`map` transform.  
-
-The {{<hover label="match" line="6">}}match{{</hover>}} 
-transform adds support for regular expressions along with exact
-strings and can provide default values if there isn't a match.
-
-A {{<hover label="match" line="7">}}match{{</hover>}} object requires a 
-{{<hover label="match" line="8">}}patterns{{</hover>}} object.
-
-The {{<hover label="match" line="8">}}patterns{{</hover>}} is a list of one or
-more patterns to attempt to match the input value against. 
-
-```yaml {label="match",copy-lines="1-8"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: match
-        match:
-          patterns:
-            - type: literal
-              # Removed for brevity
-            - type: regexp
-              # Removed for brevity
-```
-
-Match {{<hover label="match" line="8">}}patterns{{</hover>}} can be either 
-{{<hover label="match" line="9">}}type: literal{{</hover>}} to match an
-exact string or 
-{{<hover label="match" line="11">}}type: regexp{{</hover>}} to match a
-regular expression. 
-
-{{<hint "note" >}}
-Crossplane stops processing matches after the first pattern match.
-{{< /hint >}}
-
-#### Match an exact string
-Use a {{<hover label="matchLiteral" line="8">}}pattern{{</hover>}} with 
-{{<hover label="matchLiteral" line="9">}}type: literal{{</hover>}} to match an 
-exact string. 
-
-On a successful match Crossplane provides the 
-{{<hover label="matchLiteral" line="11">}}result:{{</hover>}} to
-the patch {{<hover label="matchLiteral" line="4">}}toFieldPath{{</hover>}}. 
-
-```yaml {label="matchLiteral"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: match
-        match:
-          patterns:
-            - type: literal
-              literal: "field1-text"
-              result: "matchedLiteral"
-```
-
-#### Match a regular expression
-Use a {{<hover label="matchRegex" line="8">}}pattern{{</hover>}} with 
-{{<hover label="matchRegex" line="9">}}type: regexp{{</hover>}} to match a regular
-expression.  
-Define a 
-{{<hover label="matchRegex" line="10">}}regexp{{</hover>}} key with the value of the
-regular expression to match.
-
-On a successful match Crossplane provides the 
-{{<hover label="matchRegex" line="11">}}result:{{</hover>}} to
-the patch {{<hover label="matchRegex" line="4">}}toFieldPath{{</hover>}}. 
-
-```yaml {label="matchRegex"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: match
-        match:
-          patterns:
-            - type: regexp
-              regexp: '^field1.*'
-              result: "foundField1"
-```
-
-#### Using default values
-
-Optionally you can provide a default value to use if there is no matching 
-pattern.  
-
-The default value can either be the original input value or a defined default
-value. 
-
-Use
-{{<hover label="defaultValue" line="12">}}fallbackTo: Value{{</hover>}} to
-provide a default value if a match isn't found.
-
-For example if the string 
-{{<hover label="defaultValue" line="10">}}unknownString{{</hover>}} isn't
-matched, Crossplane provides the 
-{{<hover label="defaultValue" line="12">}}Value{{</hover>}} 
-{{<hover label="defaultValue" line="13">}}StringNotFound{{</hover>}} to the 
-{{<hover label="defaultValue" line="4">}}toFieldPath{{</hover>}} 
-
-
-```yaml {label="defaultValue"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: match
-        match:
-          patterns:
-            - type: literal
-              literal: "UnknownString"
-              result: "foundField1"
-          fallbackTo: Value
-          fallbackValue: "StringNotFound"
-```
-
-To use the original input as the fallback value use 
-{{<hover label="defaultInput" line="12">}}fallbackTo: Input{{</hover>}}.
-
-Crossplane uses the original 
-{{<hover label="defaultInput" line="3">}}fromFieldPath{{</hover>}} input for the 
-{{<hover label="defaultInput" line="4">}}toFieldPath{{</hover>}} value.
-```yaml {label="defaultInput"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["myAnnotation"]
-    transforms:
-      - type: match
-        match:
-          patterns:
-            - type: literal
-              literal: "UnknownString"
-              result: "foundField1"
-          fallbackTo: Input
-```
-
-### Math transforms
-
-Use the {{<hover label="math" line="6">}}math{{</hover>}} transform to multiply
-an input or apply a minimum or maximum value. 
-
-{{<hint "important">}}
-A {{<hover label="math" line="6">}}math{{</hover>}} transform only supports
-integer inputs. 
-{{< /hint >}}
-
-```yaml {label="math",copy-lines="1-7"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.numberField
-    toFieldPath: metadata.annotations["mathAnnotation"]
-    transforms:
-      - type: math
-        math:
-          ...
-```
-
-<!-- vale Google.Headings = NO -->
-#### clampMin
-<!-- vale Google.Headings = YES -->
-
-The {{<hover label="clampMin" line="8">}}type: clampMin{{</hover>}} uses a defined 
-minimum value if an input is larger than the 
-{{<hover label="clampMin" line="8">}}type: clampMin{{</hover>}} value.
-
-For example, this 
-{{<hover label="clampMin" line="8">}}type: clampMin{{</hover>}} requires an
-input to be greater than 
-{{<hover label="clampMin" line="9">}}20{{</hover>}}.
-
-If an input is lower than 
-{{<hover label="clampMin" line="9">}}20{{</hover>}}, Crossplane uses the 
-{{<hover label="clampMin" line="9">}}clampMin{{</hover>}} value for the 
-{{<hover label="clampMin" line="4">}}toFieldPath{{</hover>}}.
-
-```yaml {label="clampMin"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.numberField
-    toFieldPath: metadata.annotations["mathAnnotation"]
-    transforms:
-      - type: math
-        math:
-          type: clampMin
-          clampMin: 20
-```
-
-<!-- vale Google.Headings = NO -->
-#### clampMax
-<!-- vale Google.Headings = YES -->
-
-The {{<hover label="clampMax" line="8">}}type: clampMax{{</hover>}} uses a defined 
-minimum value if an input is larger than the 
-{{<hover label="clampMax" line="8">}}type: clampMax{{</hover>}} value.
-
-For example, this 
-{{<hover label="clampMax" line="8">}}type: clampMax{{</hover>}} requires an
-input to be less than 
-{{<hover label="clampMax" line="9">}}5{{</hover>}}.
-
-If an input is higher than 
-{{<hover label="clampMax" line="9">}}5{{</hover>}}, Crossplane uses the 
-{{<hover label="clampMax" line="9">}}clampMax{{</hover>}} value for the 
-{{<hover label="clampMax" line="4">}}toFieldPath{{</hover>}}.
-
-```yaml {label="clampMax"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.numberField
-    toFieldPath: metadata.annotations["mathAnnotation"]
-    transforms:
-      - type: math
-        math:
-          type: clampMax
-          clampMax: 5
-```
-
-<!-- vale Google.Headings = NO -->
-#### Multiply
-<!-- vale Google.Headings = YES -->
-
-The {{<hover label="multiply" line="8">}}type: multiply{{</hover>}} multiplies
-the input by the {{<hover label="multiply" line="9">}}multiply{{</hover>}} 
-value.
-
-For example, this 
-{{<hover label="multiply" line="8">}}type: multiply{{</hover>}} multiplies the
-value from the {{<hover label="multiply" line="3">}}fromFieldPath{{</hover>}}
-value by {{<hover label="multiply" line="9">}}2{{</hover>}}
-
-
-```yaml {label="multiply"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.numberField
-    toFieldPath: metadata.annotations["mathAnnotation"]
-    transforms:
-      - type: math
-        math:
-          type: multiply
-          multiply: 2
-```
-
-{{<hint "note" >}}
-The {{<hover label="multiply" line="9">}}multiply{{</hover>}} value only
-supports integers.
-{{< /hint >}}
-
-### String transforms
-
-The {{<hover label="string" line="6">}}string{{</hover>}} transform applies
-string formatting or manipulation to string inputs.
-
-```yaml {label="string"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["stringAnnotation"]
-    transforms:
-      - type: string
-        string:
-          type: ...
-```
-
-String transforms support the following 
-{{<hover label="string" line="7">}}types{{</hover>}}
-
-* [Convert](#string-convert)
-* [Format](#string-format)
-* [Join](#join)
-* [Regexp](#regular-expression-type)
-* [TrimPrefix](#trim-prefix)
-* [TrimSuffix](#trim-suffix)
-
-#### String convert
-
-The {{<hover label="stringConvert" line="9">}}type: convert{{</hover>}}
-converts the input based on one of the following conversion types:
-* `ToUpper` - Change the string to all upper case letters. 
-* `ToLower` - Change the string to all lower case letters.
-* `ToBase64` - Create a new base64 string from the input. 
-* `FromBase64` - Create a new text string from a base64 input.
-* `ToJson` - Convert the input string to valid JSON.
-* `ToSha1` - Create a SHA-1 hash of the input string.
-* `ToSha256` - Create a SHA-256 hash of the input string.
-* `ToSha512` - Create a SHA-512 hash of the input string.
-* `ToAdler32` - Create an Adler32 hash of the input string.
-
-```yaml {label="stringConvert"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["FIELD1-TEXT"]
-    transforms:
-      - type: string
-        string:
-          type: Convert
-          convert: "ToUpper"
-```
-
-#### String format
-The {{<hover label="typeFormat" line="9">}}type: format{{</hover>}}
-applies [Go string formatting](https://pkg.go.dev/fmt) to the input. 
-
-```yaml {label="typeFormat"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.field1
-    toFieldPath: metadata.annotations["stringAnnotation"]
-    transforms:
-      - type: string
-        string:
-          type: Format
-          fmt: "the-field-%s"
-```
-
-#### Join
-
-The {{<hover label="typeJoin" line="8">}}type: Join{{</hover>}} joins all
-values in the input array into a string using the given separator.
-
-This transform only works with array inputs.
-
-```yaml {label="typeJoin"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.parameters.inputList
-    toFieldPath: spec.targetJoined
-    transforms:
-      - type: string
-        string:
-          type: Join
-          join:
-            separator: ","
-```
-
-#### Regular expression type
-The {{<hover label="typeRegex" line="8">}}type: Regexp{{</hover>}} extracts
-the part of the input matching a regular expression. 
-
-Optionally use a 
-{{<hover label="typeRegex" line="11">}}group{{</hover>}} to match a regular
-expression capture group.  
-By default Crossplane matches the entire regular expression.
-
-```yaml {label="typeRegex"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.desiredRegion
-    toFieldPath: metadata.annotations["euRegion"]
-    transforms:
-      - type: string
-        string:
-          type: Regexp
-          regexp:
-            match: '^eu-(.*)-'
-            group: 1
-```
-
-#### Trim prefix
-
-The {{<hover label="typeTrimP" line="8">}}type: TrimPrefix{{</hover>}} uses 
-Go's [TrimPrefix](https://pkg.go.dev/strings#TrimPrefix) and removes characters 
-from the beginning of a line.
-
-```yaml {label="typeTrimP"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.desiredRegion
-    toFieldPath: metadata.annotations["north-1"]
-    transforms:
-      - type: string
-        string:
-          type: TrimPrefix
-          trim: `eu-
-```
-
-#### Trim suffix
-
-The {{<hover label="typeTrimS" line="8">}}type: TrimSuffix{{</hover>}} uses 
-Go's [TrimSuffix](https://pkg.go.dev/strings#TrimSuffix) and removes characters 
-from the end of a line.
-
-```yaml {label="typeTrimS"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.desiredRegion
-    toFieldPath: metadata.annotations["eu"]
-    transforms:
-      - type: string
-        string:
-          type: TrimSuffix
-          trim: `-north-1'
-```
-
-## Patch policies
-
-Crossplane supports two types of patch policies:
-* `fromFieldPath`
-* `mergeOptions`
-
-<!-- vale Google.Headings = NO -->
-### fromFieldPath policy
-<!-- vale Google.Headings = YES -->
-
-Using a `fromFieldPath: Required` policy on a patch requires the
-`fromFieldPath` to exist in the composite resource.
-
-{{<hint "tip" >}}
-If a resource patch isn't working applying the `fromFieldPath: Required` policy
-may produce an error in the composite resource to help troubleshoot. 
-{{< /hint >}}
-
-By default, Crossplane applies the policy `fromFieldPath: Optional`. With
-`fromFieldPath: Optional` Crossplane 
-ignores a patch if the `fromFieldPath` doesn't exist.   
-
-With 
-{{<hover label="required" line="6">}}fromFieldPath: Required{{</hover>}} 
-the composite resource produces an error if the
-{{<hover label="required" line="6">}}fromFieldPath{{</hover>}} doesn't exist. 
-
-```yaml {label="required"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.desiredRegion
-    toFieldPath: metadata.annotations["eu"]
-    policy:
-      fromFieldPath: Required
-```
-
-### Merge options
-
-By default when applying a patch the destination data is overridden. Use 
-{{<hover label="merge" line="6">}}mergeOptions{{</hover>}} to allow patches to 
-merge arrays and objects without overwriting them. 
-
-With an array input, use 
-{{<hover label="merge" line="7">}}appendSlice: true{{</hover>}} to append the
-array data to the end of the existing array.
-
-With an object, use 
-{{<hover label="merge" line="8">}}keepMapValues: true{{</hover>}} to leave
-existing object keys in tact. The patch updates any matching keys between the
-input and destination data. 
-
-```yaml {label="merge"}
-patches:
-  - type: FromCompositeFieldPath
-    fromFieldPath: spec.desiredRegion
-    toFieldPath: metadata.annotations["eu"]
-    policy:
-      mergeOptions:
-        appendSlice: true
-        keepMapValues: true
-```
diff --git a/content/master/concepts/server-side-apply.md b/content/master/concepts/server-side-apply.md
index 0131fdaf..c59d9878 100644
--- a/content/master/concepts/server-side-apply.md
+++ b/content/master/concepts/server-side-apply.md
@@ -58,7 +58,7 @@ feature flag together with composition functions.
 
 When you use composition functions, Crossplane uses server side apply to sync
 composite resources with composed resources. Read more about this in the
-[composition functions documentation]({{<ref "./composition-functions#how-composition-functions-work">}}).
+[composition functions documentation]({{<ref "./compositions#how-composition-functions-work">}}).
 
 ```mermaid
 graph LR
diff --git a/content/master/concepts/usages.md b/content/master/concepts/usages.md
index b6503a1e..7f74d428 100644
--- a/content/master/concepts/usages.md
+++ b/content/master/concepts/usages.md
@@ -240,33 +240,41 @@ the `Cluster` resource until the `Release` resource is successfully deleted.
 apiVersion: apiextensions.crossplane.io/v1
 kind: Composition
 spec:
-  resources:
-    - name: cluster
-      base:
-        apiVersion: container.gcp.upbound.io/v1beta1
-        kind: Cluster
-        # Removed for brevity
-    - name: release
-      base:
-        apiVersion: helm.crossplane.io/v1beta1
-        kind: Release
-        # Removed for brevity
-    - name: release-uses-cluster
-      base:
-        apiVersion: apiextensions.crossplane.io/v1alpha1
-        kind: Usage
-        spec:
-          replayDeletion: true
-          of:
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+        - name: cluster
+          base:
             apiVersion: container.gcp.upbound.io/v1beta1
             kind: Cluster
-            resourceSelector:
-              matchControllerRef: true
-          by:
+            # Removed for brevity
+        - name: release
+          base:
             apiVersion: helm.crossplane.io/v1beta1
             kind: Release
-            resourceSelector:
-              matchControllerRef: true
+            # Removed for brevity
+        - name: release-uses-cluster
+          base:
+            apiVersion: apiextensions.crossplane.io/v1alpha1
+            kind: Usage
+            spec:
+              replayDeletion: true
+              of:
+                apiVersion: container.gcp.upbound.io/v1beta1
+                kind: Cluster
+                resourceSelector:
+                  matchControllerRef: true
+              by:
+                apiVersion: helm.crossplane.io/v1beta1
+                kind: Release
+                resourceSelector:
+                  matchControllerRef: true
 ```
 
 {{<hint "tip" >}}
diff --git a/content/master/getting-started/introduction.md b/content/master/getting-started/introduction.md
index 3d15320e..b25f4170 100644
--- a/content/master/getting-started/introduction.md
+++ b/content/master/getting-started/introduction.md
@@ -225,7 +225,7 @@ metadata:
 spec:
   compositeTypeRef:
     apiVersion: test.example.org/v1alpha1
-    kind: myComputeResource
+    kind: MyComputeResource
     # Removed for brevity
 ```
 
@@ -235,9 +235,9 @@ label="comp" line="8">}}kind{{< /hover >}}.
 
 ```yaml {label="xr"}
 apiVersion: test.example.org/v1alpha1
-kind: myComputeResource
+kind: MyComputeResource
 metadata:
-  name: myResource
+  name: my-resource
 spec:
   storage: "large"
 ```
@@ -310,7 +310,7 @@ to define the _Composite Resource_ {{<hover label="xr2" line="6" >}}spec{{</hove
 spec:
   group: test.example.org
   names:
-    kind: myComputeResource
+    kind: MyComputeResource
   versions:
   - name: v1alpha1
     schema:
@@ -322,9 +322,9 @@ A _Composite Resource_ based on this _Composite Resource Definition_ looks like
 ```yaml {label="xr2"}
 # Composite Resource (XR)
 apiVersion: test.example.org/v1alpha1
-kind: myComputeResource
+kind: MyComputeResource
 metadata:
-  name: myResource
+  name: my-resource
 spec:
   storage: "large"
 ```
@@ -355,7 +355,7 @@ or {{<hover label="specVersions" line="21" >}}large{{< /hover >}}.
 spec:
   group: test.example.org
   names:
-    kind: myComputeResource
+    kind: MyComputeResource
   versions:
   - name: v1alpha1
     served: true
@@ -392,7 +392,7 @@ allows the creation of _Claims_ of `kind: computeClaim`.
 spec:
   group: test.example.org
   names:
-    kind: myComputeResource
+    kind: MyComputeResource
   claimNames:
     kind: computeClaim
   # Removed for brevity 
@@ -431,7 +431,7 @@ _Composite Resources_.
 spec:
   group: test.example.org
   names:
-    kind: myComputeResource
+    kind: MyComputeResource
   claimNames:
     kind: computeClaim
   # Removed for brevity 
@@ -477,9 +477,9 @@ The _Composite Resource Definition_ defines the
 ```yaml {label="xr-claim"}
 # Composite Resource (XR)
 apiVersion: test.example.org/v1alpha1
-kind: myComputeResource
+kind: MyComputeResource
 metadata:
-  name: myResource
+  name: my-resource
 spec:
   storage: "large"
 ```
diff --git a/content/master/getting-started/provider-aws-part-2.md b/content/master/getting-started/provider-aws-part-2.md
index c3df577f..3872c41a 100644
--- a/content/master/getting-started/provider-aws-part-2.md
+++ b/content/master/getting-started/provider-aws-part-2.md
@@ -308,10 +308,9 @@ with a template describing what infrastructure to deploy. Crossplane calls this
 template a _Composition_.
 
 The {{<hover label="comp" line="3">}}Composition{{</hover>}} defines all the 
-cloud resources to deploy.
-Each entry in the template
-is a full resource definitions, defining all the resource settings and metadata
-like labels and annotations. 
+cloud resources to deploy. Each entry in the template is a full resource
+definition, defining all the resource settings and metadata like labels and
+annotations. 
 
 This template creates an AWS 
 {{<hover label="comp" line="13">}}S3{{</hover>}}
@@ -319,13 +318,24 @@ This template creates an AWS
 {{<hover label="comp" line="33">}}DynamoDB{{</hover>}}
 {{<hover label="comp" line="34">}}Table{{</hover>}}.
 
-Crossplane uses {{<hover label="comp" line="19">}}patches{{</hover>}} to apply
-the user's input to the resource template.  
 This Composition takes the user's 
 {{<hover label="comp" line="21">}}location{{</hover>}} input and uses it as the 
 {{<hover label="comp" line="16">}}region{{</hover>}} used in the individual 
 resource.
 
+{{<hint "important" >}}
+This Composition uses an array of resource templates. You can patch each
+template with data copied from the custom API. Crossplane calls this a _Patch
+and Transform_ Composition.
+
+You don't have to use Patch and Transform. Crossplane supports a variety of
+alternatives, including Go Templating and CUE. You can also write a function in
+Go or Python to template your resources.
+
+Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
+more information on configuring Compositions and all the available options.
+{{< /hint >}}
+
 Apply this Composition to your cluster. 
 
 ```yaml {label="comp",copy-lines="all"}
@@ -335,51 +345,59 @@ kind: Composition
 metadata:
   name: dynamo-with-bucket
 spec:
-  resources:
-    - name: s3Bucket
-      base:
-        apiVersion: s3.aws.upbound.io/v1beta1
-        kind: Bucket
-        metadata:
-          name: crossplane-quickstart-bucket
-        spec:
-          forProvider:
-            region: us-east-2
-          providerConfigRef:
-            name: default
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.region"
-          transforms:
-            - type: map
-              map: 
-                EU: "eu-north-1"
-                US: "us-east-2"
-    - name: dynamoDB
-      base:
-        apiVersion: dynamodb.aws.upbound.io/v1beta1
-        kind: Table
-        metadata:
-          name: crossplane-quickstart-database
-        spec:
-          forProvider:
-            region: "us-east-2"
-            writeCapacity: 1
-            readCapacity: 1
-            attribute:
-              - name: S3ID
-                type: S
-            hashKey: S3ID
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.region"
-          transforms:
-            - type: map
-              map: 
-                EU: "eu-north-1"
-                US: "us-east-2"
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+        - name: s3Bucket
+          base:
+            apiVersion: s3.aws.upbound.io/v1beta1
+            kind: Bucket
+            metadata:
+              name: crossplane-quickstart-bucket
+            spec:
+              forProvider:
+                region: us-east-2
+              providerConfigRef:
+                name: default
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.region"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "eu-north-1"
+                    US: "us-east-2"
+        - name: dynamoDB
+          base:
+            apiVersion: dynamodb.aws.upbound.io/v1beta1
+            kind: Table
+            metadata:
+              name: crossplane-quickstart-database
+            spec:
+              forProvider:
+                region: "us-east-2"
+                writeCapacity: 1
+                readCapacity: 1
+                attribute:
+                  - name: S3ID
+                    type: S
+                hashKey: S3ID
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.region"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "eu-north-1"
+                    US: "us-east-2"
   compositeTypeRef:
     apiVersion: database.example.com/v1alpha1
     kind: NoSQL
@@ -389,14 +407,32 @@ EOF
 The {{<hover label="comp" line="52">}}compositeTypeRef{{</hover >}} defines
 which custom APIs can use this template to create resources.
 
+A Composition uses a pipeline of _composition functions_ to define the cloud
+resources to deploy. This template uses
+{{<hover label="comp" line="10">}}function-patch-and-transform{{</hover>}}.
+You must install the function before you can use it in a Composition.
+
+Apply this Function to install `function-patch-and-transform`:
+
+```yaml {label="install"}
+cat <<EOF | kubectl apply -f -
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
+spec:
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
+EOF
+```
+
 {{<hint "tip" >}}
 Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
 more information on configuring Compositions and all the available options.
 
 Read the 
-[Patch and Transform documentation]({{<ref "../concepts/patch-and-transform">}}) 
-for more information on how Crossplane uses patches to map user inputs to
-Composition resource templates.
+[Patch and Transform function documentation]({{<ref "../guides/function-patch-and-transform">}}) 
+for more information on how it uses patches to map user inputs to Composition
+resource templates.
 {{< /hint >}}
 
 View the Composition with `kubectl get composition`
diff --git a/content/master/getting-started/provider-azure-part-2.md b/content/master/getting-started/provider-azure-part-2.md
index cdc3e8e2..2c9f1340 100644
--- a/content/master/getting-started/provider-azure-part-2.md
+++ b/content/master/getting-started/provider-azure-part-2.md
@@ -295,13 +295,24 @@ This template creates an Azure
 {{<hover label="comp" line="90">}}VirtualNetwork{{</hover>}} and
 {{<hover label="comp" line="110">}}ResourceGroup{{</hover>}}.
 
-Crossplane uses {{<hover label="comp" line="34">}}patches{{</hover>}} to apply
-the user's input to the resource template.  
 This Composition takes the user's 
 {{<hover label="comp" line="36">}}location{{</hover>}} input and uses it as the 
 {{<hover label="comp" line="37">}}location{{</hover>}} used in the individual 
 resource.
 
+{{<hint "important" >}}
+This Composition uses an array of resource templates. You can patch each
+template with data copied from the custom API. Crossplane calls this a _Patch
+and Transform_ Composition.
+
+You don't have to use Patch and Transform. Crossplane supports a variety of
+alternatives, including Go Templating and CUE. You can also write a function in
+Go or Python to template your resources.
+
+Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
+more information on configuring Compositions and all the available options.
+{{< /hint >}}
+
 Apply this Composition to your cluster. 
 
 ```yaml {label="comp",copy-lines="all"}
@@ -311,122 +322,130 @@ kind: Composition
 metadata:
   name: crossplane-quickstart-vm-with-network
 spec:
-  resources:
-    - name: quickstart-vm
-      base:
-        apiVersion: compute.azure.upbound.io/v1beta1
-        kind: LinuxVirtualMachine
-        spec:
-          forProvider:
-            adminUsername: adminuser
-            adminSshKey:
-              - publicKey: ssh-rsa
-                  AAAAB3NzaC1yc2EAAAADAQABAAABAQC+wWK73dCr+jgQOAxNsHAnNNNMEMWOHYEccp6wJm2gotpr9katuF/ZAdou5AaW1C61slRkHRkpRRX9FA9CYBiitZgvCCz+3nWNN7l/Up54Zps/pHWGZLHNJZRYyAB6j5yVLMVHIHriY49d/GZTZVNB8GoJv9Gakwc/fuEZYYl4YDFiGMBP///TzlI4jhiJzjKnEvqPFki5p2ZRJqcbCiF4pJrxUQR/RXqVFQdbRLZgYfJ8xGB878RENq3yQ39d8dVOkq4edbkzwcUmwwwkYVPIoDGsYLaRHnG+To7FvMeyO7xDVQkMKzopTQV8AuKpyvpqu0a9pWOMaiCyDytO7GGN
-                  example@docs.crossplane.io
-                username: adminuser
-            location: "Central US"
-            osDisk:
-              - caching: ReadWrite
-                storageAccountType: Standard_LRS
-            resourceGroupNameSelector:
-              matchControllerRef: true
-            size: Standard_B1ms
-            sourceImageReference:
-              - offer: debian-11
-                publisher: Debian
-                sku: 11-backports-gen2
-                version: latest
-            networkInterfaceIdsSelector:
-              matchControllerRef: true
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "Sweden Central"
-                US: "Central US"
-    - name: quickstart-nic
-      base:
-        apiVersion: network.azure.upbound.io/v1beta1
-        kind: NetworkInterface
-        spec:
-          forProvider:
-            ipConfiguration:
-              - name: crossplane-quickstart-configuration
-                privateIpAddressAllocation: Dynamic
-                subnetIdSelector:
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+        - name: quickstart-vm
+          base:
+            apiVersion: compute.azure.upbound.io/v1beta1
+            kind: LinuxVirtualMachine
+            spec:
+              forProvider:
+                adminUsername: adminuser
+                adminSshKey:
+                  - publicKey: ssh-rsa
+                      AAAAB3NzaC1yc2EAAAADAQABAAABAQC+wWK73dCr+jgQOAxNsHAnNNNMEMWOHYEccp6wJm2gotpr9katuF/ZAdou5AaW1C61slRkHRkpRRX9FA9CYBiitZgvCCz+3nWNN7l/Up54Zps/pHWGZLHNJZRYyAB6j5yVLMVHIHriY49d/GZTZVNB8GoJv9Gakwc/fuEZYYl4YDFiGMBP///TzlI4jhiJzjKnEvqPFki5p2ZRJqcbCiF4pJrxUQR/RXqVFQdbRLZgYfJ8xGB878RENq3yQ39d8dVOkq4edbkzwcUmwwwkYVPIoDGsYLaRHnG+To7FvMeyO7xDVQkMKzopTQV8AuKpyvpqu0a9pWOMaiCyDytO7GGN
+                      example@docs.crossplane.io
+                    username: adminuser
+                location: "Central US"
+                osDisk:
+                  - caching: ReadWrite
+                    storageAccountType: Standard_LRS
+                resourceGroupNameSelector:
+                  matchControllerRef: true
+                size: Standard_B1ms
+                sourceImageReference:
+                  - offer: debian-11
+                    publisher: Debian
+                    sku: 11-backports-gen2
+                    version: latest
+                networkInterfaceIdsSelector:
+                  matchControllerRef: true
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "Sweden Central"
+                    US: "Central US"
+        - name: quickstart-nic
+          base:
+            apiVersion: network.azure.upbound.io/v1beta1
+            kind: NetworkInterface
+            spec:
+              forProvider:
+                ipConfiguration:
+                  - name: crossplane-quickstart-configuration
+                    privateIpAddressAllocation: Dynamic
+                    subnetIdSelector:
+                      matchControllerRef: true
+                location: "Central US"
+                resourceGroupNameSelector:
+                  matchControllerRef: true
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "Sweden Central"
+                    US: "Central US"            
+        - name: quickstart-subnet
+          base:
+            apiVersion: network.azure.upbound.io/v1beta1
+            kind: Subnet
+            spec:
+              forProvider:
+                addressPrefixes:
+                  - 10.0.1.0/24
+                virtualNetworkNameSelector:
+                  matchControllerRef: true
+                resourceGroupNameSelector:
                   matchControllerRef: true
-            location: "Central US"
-            resourceGroupNameSelector:
-              matchControllerRef: true
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "Sweden Central"
-                US: "Central US"            
-    - name: quickstart-subnet
-      base:
-        apiVersion: network.azure.upbound.io/v1beta1
-        kind: Subnet
-        spec:
-          forProvider:
-            addressPrefixes:
-              - 10.0.1.0/24
-            virtualNetworkNameSelector:
-              matchControllerRef: true
-            resourceGroupNameSelector:
-              matchControllerRef: true
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "Sweden Central"
-                US: "Central US"
-    - name: quickstart-network
-      base:
-        apiVersion: network.azure.upbound.io/v1beta1
-        kind: VirtualNetwork
-        spec:
-          forProvider:
-            addressSpace:
-              - 10.0.0.0/16
-            location: "Central US"
-            resourceGroupNameSelector:
-              matchControllerRef: true
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "Sweden Central"
-                US: "Central US"
-    - name: crossplane-resourcegroup
-      base:
-        apiVersion: azure.upbound.io/v1beta1
-        kind: ResourceGroup
-        spec:
-          forProvider:
-            location: Central US
-      patches:
-        - type: FromCompositeFieldPath
-          fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "Sweden Central"
-                US: "Central US"
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "Sweden Central"
+                    US: "Central US"
+        - name: quickstart-network
+          base:
+            apiVersion: network.azure.upbound.io/v1beta1
+            kind: VirtualNetwork
+            spec:
+              forProvider:
+                addressSpace:
+                  - 10.0.0.0/16
+                location: "Central US"
+                resourceGroupNameSelector:
+                  matchControllerRef: true
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "Sweden Central"
+                    US: "Central US"
+        - name: crossplane-resourcegroup
+          base:
+            apiVersion: azure.upbound.io/v1beta1
+            kind: ResourceGroup
+            spec:
+              forProvider:
+                location: Central US
+          patches:
+            - type: FromCompositeFieldPath
+              fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "Sweden Central"
+                    US: "Central US"
   compositeTypeRef:
     apiVersion: compute.example.com/v1alpha1
     kind: VirtualMachine
@@ -436,14 +455,32 @@ EOF
 The {{<hover label="comp" line="52">}}compositeTypeRef{{</hover >}} defines
 which custom APIs can use this template to create resources.
 
+A Composition uses a pipeline of _composition functions_ to define the cloud
+resources to deploy. This template uses
+{{<hover label="comp" line="10">}}function-patch-and-transform{{</hover>}}.
+You must install the function before you can use it in a Composition.
+
+Apply this Function to install `function-patch-and-transform`:
+
+```yaml {label="install"}
+cat <<EOF | kubectl apply -f -
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
+spec:
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
+EOF
+```
+
 {{<hint "tip" >}}
 Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
 more information on configuring Compositions and all the available options.
 
 Read the 
-[Patch and Transform documentation]({{<ref "../concepts/patch-and-transform">}}) 
-for more information on how Crossplane uses patches to map user inputs to
-Composition resource templates.
+[Patch and Transform function documentation]({{<ref "../guides/function-patch-and-transform">}}) 
+for more information on how it uses patches to map user inputs to Composition
+resource templates.
 {{< /hint >}}
 
 View the Composition with `kubectl get composition`
diff --git a/content/master/getting-started/provider-gcp-part-2.md b/content/master/getting-started/provider-gcp-part-2.md
index 7d9552a9..916a240e 100644
--- a/content/master/getting-started/provider-gcp-part-2.md
+++ b/content/master/getting-started/provider-gcp-part-2.md
@@ -337,13 +337,24 @@ This template creates a GCP
 {{<hover label="comp" line="25">}}PubSub{{</hover>}}
 {{<hover label="comp" line="26">}}Topic{{</hover>}}.
 
-Crossplane uses {{<hover label="comp" line="15">}}patches{{</hover>}} to apply
-the user's input to the resource template.  
 This Composition takes the user's 
 {{<hover label="comp" line="16">}}location{{</hover>}} input and uses it as the 
 {{<hover label="comp" line="14">}}location{{</hover>}} used in the individual 
 resource.
 
+{{<hint "important" >}}
+This Composition uses an array of resource templates. You can patch each
+template with data copied from the custom API. Crossplane calls this a _Patch
+and Transform_ Composition.
+
+You don't have to use Patch and Transform. Crossplane supports a variety of
+alternatives, including Go Templating and CUE. You can also write a function in
+Go or Python to template your resources.
+
+Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
+more information on configuring Compositions and all the available options.
+{{< /hint >}}
+
 Apply this Composition to your cluster. 
 
 ```yaml {label="comp",copy-lines="all"}
@@ -353,39 +364,47 @@ kind: Composition
 metadata:
   name: topic-with-bucket
 spec:
-  resources:
-    - name: crossplane-quickstart-bucket
-      base:
-        apiVersion: storage.gcp.upbound.io/v1beta1
-        kind: Bucket
-        spec:
-          forProvider:
-            location: "US"
-      patches:
-        - fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.location"
-          transforms:
-            - type: map
-              map: 
-                EU: "EU"
-                US: "US"
-    - name: crossplane-quickstart-topic
-      base:
-        apiVersion: pubsub.gcp.upbound.io/v1beta1
-        kind: Topic
-        spec:
-          forProvider:
-            messageStoragePolicy:
-              - allowedPersistenceRegions: 
-                - "us-central1"
-      patches:
-        - fromFieldPath: "spec.location"
-          toFieldPath: "spec.forProvider.messageStoragePolicy[0].allowedPersistenceRegions[0]"
-          transforms:
-            - type: map
-              map: 
-                EU: "europe-central2"
-                US: "us-central1"
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+        - name: crossplane-quickstart-bucket
+          base:
+            apiVersion: storage.gcp.upbound.io/v1beta1
+            kind: Bucket
+            spec:
+              forProvider:
+                location: "US"
+          patches:
+            - fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.location"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "EU"
+                    US: "US"
+        - name: crossplane-quickstart-topic
+          base:
+            apiVersion: pubsub.gcp.upbound.io/v1beta1
+            kind: Topic
+            spec:
+              forProvider:
+                messageStoragePolicy:
+                  - allowedPersistenceRegions: 
+                    - "us-central1"
+          patches:
+            - fromFieldPath: "spec.location"
+              toFieldPath: "spec.forProvider.messageStoragePolicy[0].allowedPersistenceRegions[0]"
+              transforms:
+                - type: map
+                  map: 
+                    EU: "europe-central2"
+                    US: "us-central1"
   compositeTypeRef:
     apiVersion: queue.example.com/v1alpha1
     kind: PubSub
@@ -395,14 +414,32 @@ EOF
 The {{<hover label="comp" line="40">}}compositeTypeRef{{</hover >}} defines
 which custom APIs can use this template to create resources.
 
+A Composition uses a pipeline of _composition functions_ to define the cloud
+resources to deploy. This template uses
+{{<hover label="comp" line="10">}}function-patch-and-transform{{</hover>}}.
+You must install the function before you can use it in a Composition.
+
+Apply this Function to install `function-patch-and-transform`:
+
+```yaml {label="install"}
+cat <<EOF | kubectl apply -f -
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
+spec:
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
+EOF
+```
+
 {{<hint "tip" >}}
 Read the [Composition documentation]({{<ref "../concepts/compositions">}}) for
 more information on configuring Compositions and all the available options.
 
 Read the 
-[Patch and Transform documentation]({{<ref "../concepts/patch-and-transform">}}) 
-for more information on how Crossplane uses patches to map user inputs to
-Composition resource templates.
+[Patch and Transform function documentation]({{<ref "../guides/function-patch-and-transform">}}) 
+for more information on how it uses patches to map user inputs to Composition
+resource templates.
 {{< /hint >}}
 
 View the Composition with `kubectl get composition`
diff --git a/content/master/guides/function-patch-and-transform.md b/content/master/guides/function-patch-and-transform.md
new file mode 100644
index 00000000..64d045c5
--- /dev/null
+++ b/content/master/guides/function-patch-and-transform.md
@@ -0,0 +1,2074 @@
+---
+title: Function Patch and Transform
+weight: 70
+description: "A function that use patches and transforms to modify inputs from claims and composite resources before creating managed resources"
+---
+
+Function Patch and Transform allows you to write a Composition that specifies
+templated managed resources (MRs), and uses "patch and transform" operations to
+fill out the templates. The templates are filled out with values copied from a
+claim or composite resource (XR).
+
+A [patch](#create-a-patch) copies a value from one resource and _patches_ it
+onto another resource. A [transform](#transform-a-patch) modifies the values
+before applying the patch.
+
+Here's an example Composition that uses Function Patch and Transform. When you
+create an `AcmeBucket` XR that uses this Composition, Crossplane will create the
+templated Amazon S3 `Bucket` MR.
+
+Crossplane will copy the value from the `AcmeBucket` XR's `spec.desiredRegion`
+field and patch it onto the `Bucket` MR's `spec.forProvider.region` field.
+
+```yaml {label="intro"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: example
+spec:
+  compositeTypeRef:
+    apiVersion: custom-api.example.org/v1alpha1
+    kind: AcmeBucket
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: storage-bucket
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+          spec:
+            forProvider:
+              region: "us-east-2"
+        patches:
+        - type: FromCompositeFieldPath
+          fromFieldPath: spec.desiredRegion
+          toFieldPath: spec.forProvider.region
+```
+
+{{<hint "note" >}}
+Patch and transform is best for simpler compositions. It intentionally doesn't
+support features like loops and conditionals.
+{{</hint >}}
+
+{{<expand "Confused about Compositions, XRDs, XRs and Claims?" >}}
+Crossplane has four core components that users commonly mix up:
+
+* [Composition]({{<ref "../concepts/compositions">}}) - A template to define
+  how to create resources.
+* [composite resource Definition]({{<ref "../concepts/composite-resource-definitions">}})
+  (`XRD`) - A custom API specification. 
+* [composite resource]({{<ref "../concepts/composite-resources">}}) (`XR`) -
+  Created by using the custom API defined in a composite resource Definition.
+  XRs use the Composition template to create new managed resources. 
+* [Claim]({{<ref "../concepts/claims" >}}) (`XRC`) - Like a composite resource,
+  but with namespace scoping. 
+{{</expand >}}
+
+## Install the function
+
+You must install Function Patch and Transform before you can use it in a
+Composition. Apply this manifest to install Function Patch and Transform:
+
+```yaml
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-patch-and-transform
+spec:
+  package: xpkg.upbound.io/crossplane-contrib/function-patch-and-transform:v0.1.4
+```
+
+{{<hint "tip" >}}
+Read the [Composition page]({{<ref "../concepts/compositions">}}) to learn more
+about Compositions and composition functions.
+{{< /hint >}}
+
+
+##  Resource templates
+
+The `resources` field the function's input defines the set of things that a
+composite resource creates when it uses this function.
+
+For example, the input can define a template to create a virtual machine and an
+associated storage bucket at the same time. 
+
+{{<hint "tip" >}}
+Crossplane calls the templated resources _composed resources_.
+{{< /hint >}}
+
+The `resources` field lists the individual resources with a `name`. This name
+identifies the resource inside the Composition. It isn't related to the external
+name used with the Provider.
+
+The contents of the `base` are identical to creating a standalone
+[managed resource]({{<ref "../concepts/managed-resources">}}).
+
+This example uses 
+[Upbound's Provider AWS](https://marketplace.upbound.io/providers/upbound/provider-aws/v0.35.0)
+to define a S3 storage `Bucket` and EC2 compute `Instance`.
+
+After defining the `apiVersion` and `kind`, define the `spec.forProvider` fields
+defining the settings of the resource.
+
+```yaml {copy-lines="none",label="resources"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: storage-bucket
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: "us-east-2"
+- name: vm
+  base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: Instance
+    spec:
+      forProvider:
+        ami: ami-0d9858aa3c6322f73
+        instanceType: t2.micro
+        region: "us-east-2"
+```
+
+When a [composite resource]({{<ref "../concepts/composite-resources" >}}) uses
+this function, the composite resource creates two new managed resources with all
+the provided `spec.forProvider` settings.
+
+The `spec` supports any settings used in a managed resource, including applying
+`annotations` and `labels` or using a specific `providerConfigRef`.
+
+{{<hint "note" >}}
+Use the `crossplane.io/external-name` annotation on the resource to set
+the resource's name in the external system (like AWS).
+{{< /hint >}}
+
+{{<hint "tip" >}}
+You can use Function Patch and Transform to template other kinds of Crossplane
+resources, like ProviderConfigs.
+
+You can also template other kinds of composite resource (XR).
+
+You can't template namespaced resources.
+{{< /hint >}}
+
+## Create a patch
+
+Each entry in the `resources` list can include a list of patches. The `patches`
+field takes a list of patches to apply to the individual resource. 
+
+Each patch has a `type`, which defines what kind of patch action Crossplane
+applies. 
+
+Patches reference fields inside different resources depending on the patch type,
+but all patches reference a `fromFieldPath` and `toFieldPath`.
+
+The `fromFieldPath` is the path to the patch's input values. The `toFieldPath`
+is the path the patch will apply to.
+
+Here's an example of a patch that copies a value from the composite resource's
+`spec.field1` field to the composed Bucket's labels.
+
+```yaml {label="createComp",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: storage-bucket
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: "us-east-2"
+  patches:
+    - type: FromCompositeFieldPath
+      fromFieldPath: spec.field1
+      toFieldPath: metadata.labels["patchLabel"]
+```
+
+### Selecting fields
+
+Crossplane selects fields in a composite resource or managed resource with a
+subset of [JSONPath selectors](https://kubernetes.io/docs/reference/kubectl/jsonpath/),
+called "field paths."
+
+Field paths can select any field in a composite resource or managed resource
+object, including the `metadata`, `spec` or `status` fields. 
+
+Field paths can be a string matching a field name or an array index, in
+brackets. Field names may use a `.` character to select child elements.
+
+#### Example field paths
+Here are some example selectors from a composite resource object.
+{{<table "table" >}}
+| Selector | Selected element | 
+| --- | --- |
+| `kind` | `kind` |
+| `metadata.labels['crossplane.io/claim-name']` | `my-example-claim` |
+| `spec.desiredRegion` | `eu-north-1` |
+| `spec.resourceRefs[0].name` | `my-example-claim-978mh-r6z64` |
+{{</table >}}
+
+```yaml {label="select",copy-lines="none"}
+$ kubectl get composite -o yaml
+apiVersion: example.org/v1alpha1
+kind: XExample
+metadata:
+  # Removed for brevity
+  labels:
+    crossplane.io/claim-name: my-example-claim
+    crossplane.io/claim-namespace: default
+    crossplane.io/composite: my-example-claim-978mh
+spec:
+  desiredRegion: eu-north-1
+  field1: field1-text
+  resourceRefs:
+  - apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    name: my-example-claim-978mh-r6z64
+  - apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    name: my-example-claim-978mh-cnlhj
+  - apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    name: my-example-claim-978mh-rv5nm
+```
+
+## Reuse a patch
+
+You can reuse a patch object on multiple resources by using a PatchSet.
+
+To create a PatchSet, define a `patchSets` object in the function's input.
+
+Each patch inside a PatchSet has a `name` and a list of `patches`.  
+
+Apply the PatchSet to a resource with a patch `type: PatchSet`. Set the
+`patchSetName` to the `name` of the PatchSet.
+
+```yaml {label="patchset"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+patchSets:
+- name: my-patchset
+  patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: spec.forProvider.region
+resources:
+- name: bucket1
+  base:
+    # Removed for brevity
+  patches:
+    - type: PatchSet
+      patchSetName: my-patchset
+- name: bucket2
+  base:
+    # Removed for brevity
+  patches:
+    - type: PatchSet
+      patchSetName: my-patchset  
+```
+
+{{<hint "important" >}}
+A PatchSet can't contain other PatchSets.  
+
+Crossplane ignores any [transforms](#transform-a-patch) or
+[policies](#patch-policies) in a PatchSet.
+{{< /hint >}}
+
+## Patching between resources
+
+Function Patch and Transform can't directly patch between two templated composed
+resources. For example, generating a network resource and patching the resource
+name to a compute resource. 
+
+A resource can patch to a user-defined `status` field in the composite resource.
+Another resource can then read from that `Status` field to patch a field. 
+
+First, define a custom `status` in the composite resource Definition and a
+custom field, for example `secondResource`
+
+```yaml {label="xrdPatch",copy-lines="13-17"}
+kind: CompositeResourceDefinition
+# Removed for brevity.
+spec:
+  # Removed for brevity.
+  versions:
+  - name: v1alpha1
+    schema:
+      openAPIV3Schema:
+        type: object
+        properties:
+          spec:
+            # Removed for brevity.
+          status:
+              type: object
+              properties:
+                secondResource:
+                  type: string
+```
+
+Inside the function input the resource with the source data uses a
+`ToCompositeFieldPath` patch to write data to the `status.secondResource` field
+in the composite resource. 
+
+The destination resource uses a `FromCompositeFieldPath` patch to read data from
+the composite resource `status.secondResource` field in the composite resource
+and write it to a label named `secondResource` in the managed resource.
+
+```yaml {label="patchBetween",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    # Removed for brevity
+  patches:
+    - type: ToCompositeFieldPath
+      fromFieldPath: metadata.name
+      toFieldPath: status.secondResource
+- name: bucket2
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    # Removed for brevity
+  patches:
+    - type: FromCompositeFieldPath
+      fromFieldPath: status.secondResource
+      toFieldPath: metadata.labels['secondResource']
+```
+
+Describe the composite resource to view the `resources` and the
+`status.secondResource` value. 
+
+```yaml {label="descCompPatch",copy-lines="none"}
+$ kubectl describe composite
+Name:         my-example-claim-jp7rx
+Spec:
+  # Removed for brevity
+  Resource Refs:
+    Name:         my-example-claim-jp7rx-gfg4m
+    # Removed for brevity
+    Name:         my-example-claim-jp7rx-fttpj
+Status:
+  # Removed for brevity
+  Second Resource:         my-example-claim-jp7rx-gfg4m
+```
+
+Describe the destination managed resource to see the label `secondResource`.
+
+```yaml {label="bucketlabel",copy-lines="none"}
+$ kubectl describe bucket
+kubectl describe bucket my-example-claim-jp7rx-fttpj
+Name:         my-example-claim-jp7rx-fttpj
+Labels:       crossplane.io/composite=my-example-claim-jp7rx
+              secondResource=my-example-claim-jp7rx-gfg4m
+```
+
+## Patch with EnvironmentConfigs 
+
+Crossplane uses EnvironmentConfigs to create in-memory data stores. Compositions 
+can read and write from this data store as part of the patch process. 
+
+{{<hint "important" >}}
+EnvironmentConfigs are an alpha feature. Alpha features aren't enabled by
+default. 
+{{< /hint >}}
+
+ EnvironmentConfigs can predefine data that Compositions can use or a composite
+ resource can write data to their in-memory environment for other resources to
+ read. 
+
+<!-- vale off -->
+{{< hint "note" >}}
+<!-- vale on --> 
+Read the [EnvironmentConfigs]({{<ref "../concepts/environment-configs" >}}) page
+for more information on using EnvironmentConfigs.
+{{< /hint >}}
+
+To apply a patch using EnvironmentConfigs, first define which EnvironmentConfigs
+to use with 
+`environment.environmentConfigs`. 
+
+<!-- vale Google.Quotes = NO -->
+<!-- vale gitlab.SentenceLength = NO -->
+<!-- ignore false positive -->
+Use either a
+[reference]({{<ref "../concepts/managed-resources#matching-by-name-reference" >}})
+or a [selector]({{<ref "../concepts/managed-resources#matching-by-selector" >}}) to
+identify the EnvironmentConfigs to use.
+<!-- vale Google.Quotes = YES -->
+
+```yaml {label="envselect",copy-lines="none"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+# Removed for Brevity
+spec:
+  environment:
+    environmentConfigs:
+      - ref:
+          name: example-environment
+  # Removed for Brevity
+```
+
+### Patch a composite resource
+To patch between the composite resource and the in-memory environment use
+`patches` inside of the `environment`.
+
+Use the `ToCompositeFieldPath` to copy data from the in-memory environment to
+the composite resource.  
+
+Use the `FromCompositeFieldPath` to copy data from the composite resource to the
+in-memory environment.
+
+```yaml {label="xrpatch",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+environment:
+  patches:
+  - type: ToCompositeFieldPath
+    fromFieldPath: tags
+    toFieldPath: metadata.labels[envTag]
+  - type: FromCompositeFieldPath
+    fromFieldPath: metadata.name
+    toFieldPath: newEnvironmentKey
+```
+
+Individual resources can use any data written to their in-memory environment.
+
+### Patch an individual resource
+
+To patch an individual resource, inside the `patches` of the resource, use
+`ToEnvironmentFieldPath` to copy data from the resource to the in-memory
+environment.  
+
+Use `FromEnvironmentFieldPath` to copy data to the resource from the in-memory
+environment.
+
+```yaml {label="envpatch",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: vpc
+  base:
+    apiVersion: ec2.aws.upbound.io/v1beta1
+    kind: VPC
+    spec:
+      forProvider:
+        cidrBlock: 172.16.0.0/16
+  patches:
+  - type: ToEnvironmentFieldPath
+    fromFieldPath: status.atProvider.id
+    toFieldPath: vpcId
+  - type: FromEnvironmentFieldPath
+    fromFieldPath: tags
+    toFieldPath: spec.forProvider.tags
+```
+
+The [EnvironmentConfigs]({{<ref "../concepts/environment-configs" >}}) page has 
+more information on EnvironmentConfigs options and usage.
+
+## Types of patches
+Function Patch and Transform supports multiple patch types, each using a
+different source for data and applying the patch to a different location. 
+
+Summary of Crossplane patches
+{{< table "table table-hover" >}}
+| Patch Type | Data Source | Data Destination | 
+| ---  | --- | --- | 
+| [FromCompositeFieldPath](#fromcompositefieldpath) | A field in the composite resource. | A field in the composed resource. | 
+| [ToCompositeFieldPath](#tocompositefieldpath) | A field in the composed resource. | A field in the composite resource. |  
+| [CombineFromComposite](#combinefromcomposite) | Multiple fields in the composite resource. | A field in the composed resource. | 
+| [CombineToComposite](#combinetocomposite) | Multiple fields in the composed resource. | A field in the composite resource. | 
+| [FromEnvironmentFieldPath](#fromenvironmentfieldpath) | Data in the in-memory environment | A field in the composed resource. | 
+| [ToEnvironmentFieldPath](#toenvironmentfieldpath) | A field in the composed resource. | The in-memory environment. | 
+| [CombineFromEnvironment](#combinefromenvironment) | Multiple fields in the in-memory environment. | A field in the composed resource. | 
+| [CombineToEnvironment](#combinetoenvironment) | Multiple fields in the composed resource. | A field in the in-memory environment. | 
+{{< /table >}}
+
+{{<hint "note" >}}
+All the following examples use the same set of Compositions,
+CompositeResourceDefinitions, Claims and EnvironmentConfigs.  
+Only the applied patches change between examples. 
+
+All examples rely on Upbound
+[provider-aws-s3](https://marketplace.upbound.io/providers/upbound/provider-aws-s3/)
+to create resources.
+
+{{< expand "Reference Composition" >}}
+```yaml {copy-lines="all"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: example-composition
+spec:
+  compositeTypeRef:
+    apiVersion: example.org/v1alpha1
+    kind: xExample
+  environment:
+    environmentConfigs:
+    - ref:
+        name: example-environment
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: bucket1
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+          spec:
+            forProvider:
+              region: us-east-2
+      - name: bucket2
+        base:
+          apiVersion: s3.aws.upbound.io/v1beta1
+          kind: Bucket
+          spec:
+            forProvider:
+              region: us-east-2
+```
+{{< /expand >}}
+
+{{<expand "Reference CompositeResourceDefinition" >}}
+```yaml {copy-lines="all"}
+apiVersion: apiextensions.crossplane.io/v1
+kind: CompositeResourceDefinition
+metadata:
+  name: xexamples.example.org
+spec:
+  group: example.org
+  names:
+    kind: xExample
+    plural: xexamples
+  claimNames:
+    kind: ExampleClaim
+    plural: exampleclaims
+  versions:
+  - name: v1alpha1
+    served: true
+    referenceable: true
+    schema:
+      openAPIV3Schema:
+        type: object
+        properties:
+          spec:
+            type: object
+            properties:
+              field1:
+                type: string
+              field2:
+                type: string
+              field3: 
+                type: string
+              desiredRegion: 
+                type: string
+              boolField:
+                type: boolean
+              numberField:
+                type: integer
+          status:
+              type: object
+              properties:
+                url:
+                  type: string
+```
+{{< /expand >}}
+
+
+{{< expand "Reference Claim" >}}
+```yaml {copy-lines="all"}
+apiVersion: example.org/v1alpha1
+kind: ExampleClaim
+metadata:
+  name: my-example-claim
+spec:
+  field1: "field1-text"
+  field2: "field2-text"
+  desiredRegion: "eu-north-1"
+  boolField: false
+  numberField: 10
+```
+{{< /expand >}}
+
+{{< expand "Reference EnvironmentConfig" >}}
+```yaml {copy-lines="all"}
+apiVersion: apiextensions.crossplane.io/v1alpha1
+kind: EnvironmentConfig
+metadata:
+  name: example-environment
+data:
+  locations:
+    us: us-east-2
+    eu: eu-north-1
+  key1: value1
+  key2: value2
+
+```
+{{< /expand >}}
+{{< /hint >}}
+
+<!-- vale Google.Headings = NO -->
+### FromCompositeFieldPath
+<!-- vale Google.Headings = YES -->
+
+The `FromCompositeFieldPath` patch takes a value in a composite resource and
+applies it to a field in the composed resource. 
+
+{{< hint "tip" >}}
+Use the `FromCompositeFieldPath` patch to apply options from users in their
+Claims to settings in managed resource `forProvider` settings. 
+{{< /hint >}}
+
+For example, to use the value `desiredRegion` provided by a user in a composite
+resource to a managed resource's `region`. 
+
+The `fromFieldPath` value is a field in the composite resource. 
+
+The `toFieldPath` value is the field in the composed resource to change. 
+
+```yaml {label="fromComposite",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: FromCompositeFieldPath
+      fromFieldPath: spec.desiredRegion
+      toFieldPath: spec.forProvider.region
+```
+
+View the managed resource to see the updated `region`
+
+```yaml {label="fromCompMR",copy-lines="1"}
+$ kubectl describe bucket
+Name:         my-example-claim-qlr68-29nqf
+# Removed for brevity
+Spec:
+  For Provider:
+    Region:  eu-north-1
+```
+
+<!-- vale Google.Headings = NO -->
+### ToCompositeFieldPath
+<!-- vale Google.Headings = YES -->
+
+The `ToCompositeFieldPath` writes data from an individual composed resource to
+the composite resource that created it.
+
+{{< hint "tip" >}}
+Use `ToCompositeFieldPath` patches to take data from one composed resource in a
+Composition and use it in a second composed resource in the same Composition.
+{{< /hint >}}
+
+For example, after Crossplane creates a new managed resource, take the value
+`hostedZoneID` and apply it as a `label` in the composite resource.
+
+```yaml {label="toComposite",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: ToCompositeFieldPath
+      fromFieldPath: status.atProvider.hostedZoneId
+      toFieldPath: metadata.labels['ZoneID']
+```
+
+View the created managed resource to see the 
+`Hosted Zone Id` field.
+```yaml {label="toCompMR",copy-lines="none"}
+$ kubectl describe bucket
+Name:         my-example-claim-p5pxf-5vnp8
+# Removed for brevity
+Status:
+  At Provider:
+    Hosted Zone Id:       Z2O1EMRO9K5GLX
+    # Removed for brevity
+```
+
+Next view the composite resource and confirm the patch applied the `label`
+
+```yaml {label="toCompositeXR",copy-lines="none"}
+$ kubectl describe composite
+Name:         my-example-claim-p5pxf
+Labels:       ZoneID=Z2O1EMRO9K5GLX
+```
+
+<!-- vale Google.Headings = NO -->
+### CombineFromComposite
+<!-- vale Google.Headings = YES -->
+
+The `CombineFromComposite` patch takes values from the composite resource,
+combines them and applies them to the composed resource. 
+
+{{< hint "tip" >}}
+Use the `CombineFromComposite` patch to create complex strings, like security
+policies and apply them to a composed resource. 
+{{< /hint >}}
+
+For example, use the Claim value `desiredRegion` and `field2` to generate the
+managed resource's `name`
+
+The `CombineFromComposite` patch only supports the `combine` option. 
+
+The `variables` are the list of `fromFieldPath` values from the composite
+resource to combine. 
+
+The only supported `strategy` is `strategy: string`.
+
+Optionally you can apply a `string.fmt`, based on
+[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the
+strings.
+
+The `toFieldPath` is the field in the composed resource to apply the new string
+to. 
+
+```yaml {label="combineFromComp",copy-lines="11-20"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: CombineFromComposite
+      combine:
+        variables:
+          - fromFieldPath: spec.desiredRegion
+          - fromFieldPath: spec.field2
+        strategy: string
+        string:
+          fmt: "my-resource-%s-%s"
+      toFieldPath: metadata.name
+```
+
+Describe the managed resource to see the applied patch.
+
+```yaml {label="describeCombineFromComp",copy-lines="none"}
+$ kubectl describe bucket
+Name:         my-resource-eu-north-1-field2-text
+```
+
+<!-- vale Google.Headings = NO -->
+### CombineToComposite
+<!-- vale Google.Headings = YES -->
+
+The `CombineToComposite` patch takes values from the composed resource, combines
+them and applies them to the composite resource. 
+
+{{<hint "tip" >}}
+Use `CombineToComposite` patches to create a single field like a URL from
+multiple fields in a managed resource. 
+{{< /hint >}}
+
+For example, use the managed resource `name` and `region` to generate a custom
+`url` field. 
+
+{{< hint "important" >}}
+Writing custom fields in the status field of a composite resource requires
+defining the custom fields in the CompositeResourceDefinition first. 
+{{< /hint >}}
+
+The `CombineToComposite` patch only supports the `combine` option. 
+
+The `variables` are the list of `fromFieldPath` the managed resource to combine. 
+
+The only supported `strategy` is `strategy: string`.
+
+Optionally you can apply a `string.fmt`, based on 
+[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
+strings.
+
+The `toFieldPath` is the field in the composite resource to apply the new string
+to. 
+
+```yaml {label="combineToComposite",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: CombineToComposite
+      combine:
+        variables:
+          - fromFieldPath: metadata.name
+          - fromFieldPath: spec.forProvider.region
+        strategy: string
+        string:
+          fmt: "https://%s.%s.com"
+      toFieldPath: status.url
+```
+
+View the composite resource to verify the applied patch.
+
+```yaml {copy-lines="none"}
+$ kubectl describe composite
+Name:         my-example-claim-bjdjw
+API Version:  example.org/v1alpha1
+Kind:         xExample
+# Removed for brevity
+Status:
+  # Removed for brevity
+  URL:                     https://my-example-claim-bjdjw-r6ncd.us-east-2.com
+```
+
+<!-- vale Google.Headings = NO -->
+### FromEnvironmentFieldPath
+<!-- vale Google.Headings = YES -->
+
+{{<hint "important" >}}
+EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
+
+For more information about using an EnvironmentConfig, read the 
+[EnvironmentConfigs documentation]({{<ref "../concepts/environment-configs">}}).
+{{< /hint >}}
+
+The `FromEnvironmentFieldPath` patch takes values from the in-memory environment
+and applies them to the composed resource.
+
+{{<hint "tip" >}}
+Use `FromEnvironmentFieldPath` to apply custom managed resource settings based
+on the current environment.  
+{{< /hint >}}
+
+For example, use the environment's `locations.eu` value and apply it as the
+`region`.
+
+```yaml {label="fromEnvField",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+    patches:
+    - type: FromEnvironmentFieldPath
+      fromFieldPath: locations.eu
+      toFieldPath: spec.forProvider.region
+```
+
+Verify managed resource to confirm the applied patch. 
+
+```yaml {copy-lines="none"}
+kubectl describe bucket
+Name:         my-example-claim-8vrvc-xx5sr
+Labels:       crossplane.io/claim-name=my-example-claim
+# Removed for brevity
+Spec:
+  For Provider:
+    Region:  eu-north-1
+  # Removed for brevity
+```
+
+<!-- vale Google.Headings = NO -->
+### ToEnvironmentFieldPath
+<!-- vale Google.Headings = YES -->
+
+{{<hint "important" >}}
+EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
+
+For more information about using an EnvironmentConfig, read the 
+[EnvironmentConfigs documentation]({{<ref "../concepts/environment-configs">}}).
+{{< /hint >}}
+
+The `ToEnvironmentFieldPath` patch takes a value from the composed resource and
+applies it to the in-memory environment.
+
+{{<hint "tip" >}}
+Use `ToEnvironmentFieldPath` to write data to the environment that any
+FromEnvironmentFieldPath patch can access. 
+{{< /hint >}}
+
+For example, use the desired `region` value and apply it as the environment's
+`key1`.
+
+
+```yaml {label="toEnvField",copy-lines="9-11"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+    patches:
+    - type: ToEnvironmentFieldPath
+      fromFieldPath: spec.forProvider.region
+      toFieldPath: key1
+```
+
+Because the environment is in-memory, there is no command to confirm the patch
+wrote the value to the environment.
+
+
+<!-- vale Google.Headings = NO -->
+### CombineFromEnvironment
+<!-- vale Google.Headings = YES -->
+
+{{<hint "important" >}}
+EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
+
+For more information about using an EnvironmentConfig, read the 
+[EnvironmentConfigs documentation]({{<ref "../concepts/environment-configs">}}).
+{{< /hint >}}
+
+The `CombineFromEnvironment` patch combines multiple values from the in-memory
+environment and applies them to the composed resource.
+
+{{<hint "tip" >}}
+Use `CombineFromEnvironment` patch to create complex strings, like security
+policies and apply them to a managed resource. 
+{{< /hint >}}
+
+For example, combine multiple fields in the environment to create a unique
+`annotation` . 
+
+The `CombineFromEnvironment` patch only supports the `combine` option. 
+
+The only supported `strategy` is `strategy: string`.
+
+The `variables` are the list of `fromFieldPath` values from the in-memory
+environment to combine. 
+
+Optionally you can apply a `string.fmt`, based on 
+[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
+strings.
+
+The `toFieldPath` is the field in the composed resource to apply the new string
+to. 
+
+```yaml {label="combineFromEnv",copy-lines="11-20"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: CombineFromEnvironment
+      combine:
+        strategy: string
+        variables:
+        - fromFieldPath: key1
+        - fromFieldPath: key2
+        string: 
+          fmt: "%s-%s"
+      toFieldPath: metadata.annotations[EnvironmentPatch]
+```
+
+Describe the managed resource to see new 
+`annotation`.
+
+```yaml {copy-lines="none",label="combineFromEnvDesc"}
+$ kubectl describe bucket
+Name:         my-example-claim-zmxdg-grl6p
+# Removed for brevity
+Annotations:  EnvironmentPatch: value1-value2
+# Removed for brevity
+```
+
+<!-- vale Google.Headings = NO -->
+### CombineToEnvironment
+<!-- vale Google.Headings = YES -->
+
+{{<hint "important" >}}
+EnvironmentConfigs are an alpha feature. They aren't enabled by default.  
+
+For more information about using an EnvironmentConfig, read the 
+[EnvironmentConfigs documentation]({{<ref "../concepts/environment-configs">}}).
+{{< /hint >}}
+
+The `CombineToEnvironment` patch combines multiple values from the composed
+resource and applies them to the in-memory EnvironmentConfig environment.
+
+{{<hint "tip" >}}
+Use `CombineToEnvironment` patch to create complex strings, like security
+policies to use in other managed resources. 
+{{< /hint >}}
+
+For example, combine multiple fields in the managed resource to create a unique
+string and store it in the environment's `key2` value. 
+
+The string combines the managed resource `Kind` and `region`.
+
+The `CombineToEnvironment` patch only supports the `combine` option. 
+
+The only supported `strategy` is `strategy: string`.
+
+The `variables` are the list of `fromFieldPath` values in the managed resource
+to combine. 
+
+Optionally you can apply a `string.fmt`, based on 
+[Go string formatting](https://pkg.go.dev/fmt) to specify how to combine the 
+strings.
+
+The `toFieldPath` is the key in the environment to write the new string to. 
+
+```yaml {label="combineToEnv",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: CombineToEnvironment
+      combine:
+        strategy: string
+        variables:
+        - fromFieldPath: kind
+        - fromFieldPath: spec.forProvider.region
+        string:
+          fmt: "%s.%s"
+      toFieldPath: key2
+```
+
+Because the environment is in-memory, there is no command to confirm the patch
+wrote the value to the environment.
+
+## Transform a patch
+
+When applying a patch, Crossplane supports modifying the data before applying it
+as a patch. Crossplane calls this a "transform" operation. 
+
+Summary of Crossplane transforms.
+{{< table "table table-hover" >}}
+| Transform Type | Action |
+| ---  | --- |
+| [convert](#convert-transforms) | Converts an input data type to a different type. Also called "casting." | 
+| [map](#map-transforms) | Selects a specific output based on a specific input. | 
+| [match](#match-transform) | Selects a specific output based on a string or regular expression. | 
+| [math](#math-transforms) | Applies a mathematical operation on the input. | 
+| [string](#string-transforms) | Change the input string using [Go string formatting](https://pkg.go.dev/fmt). | 
+{{< /table >}}
+
+Apply a transform directly to an individual patch with the `transforms` field. 
+
+A `transform` requires a `type`, indicating the transform action to take. 
+
+The other transform field is the same as the `type`, in this example, `map`.
+
+The other fields depend on the patch type used. 
+
+This example uses a `type: map` transform, taking the input
+`spec.desiredRegion`, matching it to either `us` or `eu` and returning the
+corresponding AWS region for the `spec.forProvider.region` value. 
+
+```yaml {label="transform1",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: bucket1
+  base:
+    apiVersion: s3.aws.upbound.io/v1beta1
+    kind: Bucket
+    spec:
+      forProvider:
+        region: us-east-2
+  patches:
+    - type: FromCompositeFieldPath
+      fromFieldPath: spec.desiredRegion
+      toFieldPath: spec.forProvider.region
+      transforms:
+        - type: map
+          map:
+            us: us-east-2
+            eu: eu-north-1
+```
+
+### Convert transforms
+
+The `convert` transform type changes the input data type to a different data
+type.
+
+{{< hint "tip" >}}
+Some provider APIs require a field to be a string. Use a `convert` type to
+change any boolean or integer fields to strings. 
+{{< /hint >}}
+
+A `convert` transform requires a `toType`, defining the output data type. 
+
+```yaml {label="convert",copy-lines="none"}
+patches:
+- type: FromCompositeFieldPath
+  fromFieldPath: spec.numberField
+  toFieldPath: metadata.label["numberToString"]
+  transforms:
+    - type: convert
+      convert:
+        toType: string
+```
+
+Supported `toType` values:
+{{< table "table table-sm table-hover" >}}
+| `toType` value | Description | 
+| -- | -- |
+| `bool` | A boolean value of `true` or `false`. | 
+| `float64` | A 64-bit float value. | 
+| `int` | A 32-bit integer value. | 
+| `int64` | A 64-bit integer value. | 
+| `string` | A string value. | 
+| `object` | An object. |
+| `array` | An array. |
+{{< /table >}}
+
+#### Converting strings to booleans
+When converting from a string to a `bool` Crossplane considers the string values  
+`1`, `t`, `T`, `TRUE`, `True` and `true` equal to the boolean value `True`.  
+
+The strings `0`, `f`, `F`, `FALSE`, `False` and `false` are equal to the boolean
+value `False`. 
+
+#### Converting numbers to booleans
+Crossplane considers the integer `1` and float `1.0` equal to the boolean value
+`True`. Any other integer or float value is `False`.
+
+#### Converting booleans to numbers
+Crossplane converts the boolean value `True` to the integer `1` or float64
+`1.0`.
+
+The value `False` converts to the integer `0` or float64 `0.0`
+
+#### Converting strings to float64
+When converting from a `string` to a `float64` Crossplane supports an optional  
+`format: quantity` field.
+
+Using `format: quantity` translates size suffixes like `M` for megabyte or `Mi`
+for megabit into the correct float64 value. 
+
+{{<hint "note" >}}
+Refer to the [Go language docs](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity) 
+for a full list of supported suffixes.
+{{</hint >}}
+
+Add `format: quantity` to the `convert` object to enable quantity suffix
+support. 
+
+```yaml {label="format",copy-lines="all"}
+- type: convert
+  convert:
+   toType: float64
+   format: quantity
+```
+
+#### Converting strings to objects
+
+Crossplane converts JSON strings to objects.
+
+Add `format: json` to the `convert` object which is the only supported string
+format for this conversion.
+
+```yaml {label="object",copy-lines="all"}
+- type: convert
+  convert:
+   toType: object
+   format: json
+```
+
+{{< hint "tip" >}}
+This conversion is useful for patching keys in an object.
+{{< /hint >}}
+
+The following example adds a tag to a resource with a
+`customized key`:
+
+```yaml {label="patch-key",copy-lines="all"}
+    - type: FromCompositeFieldPath
+      fromFieldPath: spec.clusterName
+      toFieldPath: spec.forProvider.tags
+      transforms:
+      - type: string
+        string:
+          type: Format
+          fmt: '{"kubernetes.io/cluster/%s": "true"}'
+      - type: convert
+        convert:
+          toType: object
+          format: json
+```
+
+#### Converting strings to arrays
+
+Crossplane converts JSON strings to arrays.
+
+Add `format: json` to the `convert` object which is the only supported string
+format for this conversion.
+
+```yaml {label="array",copy-lines="all"}
+- type: convert
+  convert:
+   toType: array
+   format: json
+```
+
+### Map transforms
+
+The `map` transform type _maps_ an input value to an output value. 
+
+{{< hint "tip" >}}
+The `map` transform is useful for translating generic region names like `US` or
+`EU` to provider specific region names. 
+{{< /hint >}}
+
+The `map` transform compares the value from the `fromFieldPath` to the options
+listed in the `map`.  
+
+If Crossplane finds the value, Crossplane puts the mapped value in the
+`toFieldPath`.
+
+{{<hint "note" >}}
+Crossplane throws an error for the patch if the value isn't found.
+{{< /hint >}}
+
+`spec.field1` is the string `"field1-text"` then Crossplane uses the string
+`firstField` for the `annotation`.  
+
+If `spec.field1` is the string `"field2-text"` then Crossplane uses the string
+`secondField` for the `annotation`.  
+
+```yaml {label="map",copy-lines="none"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: map
+        map:
+          "field1-text": "firstField"
+          "field2-text": "secondField"
+```
+
+In this example, the value of `spec.field1` is `field1-text`.
+
+```yaml {label="comositeMap",copy-lines="none"}
+$ kubectl describe composite
+Name:         my-example-claim-twx7n
+Spec:
+  # Removed for brevity
+  field1:         field1-text
+```
+
+The annotation applied to the managed resource is `firstField`.
+
+```yaml {label="mrMap",copy-lines="none"}
+$ kubectl describe bucket
+Name:         my-example-claim-twx7n-ndb2f
+Annotations:  crossplane.io/composition-resource-name: bucket1
+              myAnnotation: firstField
+# Removed for brevity.
+```
+
+### Match transform
+
+The `match` transform is like the `map` transform.  
+
+The `match` transform adds support for regular expressions along with exact
+strings and can provide default values if there isn't a match.
+
+A `match` object requires a `patterns` object.
+
+The `patterns` is a list of one or more patterns to attempt to match the input
+value against. 
+
+```yaml {label="match",copy-lines="1-8"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: match
+        match:
+          patterns:
+            - type: literal
+              # Removed for brevity
+            - type: regexp
+              # Removed for brevity
+```
+
+Match `patterns` can be either `type: literal` to match an exact string or
+`type: regexp` to match a regular expression. 
+
+{{<hint "note" >}}
+Crossplane stops processing matches after the first pattern match.
+{{< /hint >}}
+
+#### Match an exact string
+
+Use a `pattern` with 
+`type: literal` to match an 
+exact string. 
+
+On a successful match Crossplane provides the 
+`result:` to
+the patch `toFieldPath`. 
+
+```yaml {label="matchLiteral"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: match
+        match:
+          patterns:
+            - type: literal
+              literal: "field1-text"
+              result: "matchedLiteral"
+```
+
+#### Match a regular expression
+
+Use a `pattern` with `type: regexp` to match a regular expression.  
+Define a `regexp` key with the value of the regular expression to match.
+
+On a successful match Crossplane provides the `result:` to the patch
+`toFieldPath`. 
+
+```yaml {label="matchRegex"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: match
+        match:
+          patterns:
+            - type: regexp
+              regexp: '^field1.*'
+              result: "foundField1"
+```
+
+#### Using default values
+
+Optionally you can provide a default value to use if there is no matching
+pattern.  
+
+The default value can either be the original input value or a defined default
+value. 
+
+Use `fallbackTo: Value` to provide a default value if a match isn't found.
+
+For example if the string `unknownString` isn't matched, Crossplane provides the
+`Value` `StringNotFound` to the `toFieldPath` 
+
+```yaml {label="defaultValue"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: match
+        match:
+          patterns:
+            - type: literal
+              literal: "UnknownString"
+              result: "foundField1"
+          fallbackTo: Value
+          fallbackValue: "StringNotFound"
+```
+
+To use the original input as the fallback value use `fallbackTo: Input`.
+
+Crossplane uses the original `fromFieldPath` input for the `toFieldPath` value.
+
+```yaml {label="defaultInput"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["myAnnotation"]
+    transforms:
+      - type: match
+        match:
+          patterns:
+            - type: literal
+              literal: "UnknownString"
+              result: "foundField1"
+          fallbackTo: Input
+```
+
+### Math transforms
+
+Use the `math` transform to multiply an input or apply a minimum or maximum
+value. 
+
+{{<hint "important">}}
+A `math` transform only supports integer inputs. 
+{{< /hint >}}
+
+```yaml {label="math",copy-lines="1-7"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.numberField
+    toFieldPath: metadata.annotations["mathAnnotation"]
+    transforms:
+      - type: math
+        math:
+          ...
+```
+
+<!-- vale Google.Headings = NO -->
+#### clampMin
+<!-- vale Google.Headings = YES -->
+
+The `type: clampMin` uses a defined minimum value if an input is larger than the
+`type: clampMin` value.
+
+For example, this `type: clampMin` requires an input to be greater than `20`.
+
+If an input is lower than `20`, Crossplane uses the `clampMin` value for the
+`toFieldPath`.
+
+```yaml {label="clampMin"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.numberField
+    toFieldPath: metadata.annotations["mathAnnotation"]
+    transforms:
+      - type: math
+        math:
+          type: clampMin
+          clampMin: 20
+```
+
+<!-- vale Google.Headings = NO -->
+#### clampMax
+<!-- vale Google.Headings = YES -->
+
+The `type: clampMax` uses a defined minimum value if an input is larger than the
+`type: clampMax` value.
+
+For example, this `type: clampMax` requires an input to be less than `5`.
+
+If an input is higher than `5`, Crossplane uses the `clampMax` value for the
+`toFieldPath`.
+
+```yaml {label="clampMax"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.numberField
+    toFieldPath: metadata.annotations["mathAnnotation"]
+    transforms:
+      - type: math
+        math:
+          type: clampMax
+          clampMax: 5
+```
+
+<!-- vale Google.Headings = NO -->
+#### Multiply
+<!-- vale Google.Headings = YES -->
+
+The `type: multiply` multiplies the input by the `multiply` value.
+
+For example, this `type: multiply` multiplies the value from the `fromFieldPath`
+value by `2`
+
+```yaml {label="multiply"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.numberField
+    toFieldPath: metadata.annotations["mathAnnotation"]
+    transforms:
+      - type: math
+        math:
+          type: multiply
+          multiply: 2
+```
+
+{{<hint "note" >}}
+The `multiply` value only supports integers.
+{{< /hint >}}
+
+### String transforms
+
+The `string` transform applies string formatting or manipulation to string
+inputs.
+
+```yaml {label="string"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["stringAnnotation"]
+    transforms:
+      - type: string
+        string:
+          type: ...
+```
+
+String transforms support the following 
+`types`
+
+* [Convert](#string-convert)
+* [Format](#string-format)
+* [Join](#join)
+* [Regexp](#regular-expression-type)
+* [TrimPrefix](#trim-prefix)
+* [TrimSuffix](#trim-suffix)
+
+#### String convert
+
+The `type: convert`
+converts the input based on one of the following conversion types:
+* `ToUpper` - Change the string to all upper case letters. 
+* `ToLower` - Change the string to all lower case letters.
+* `ToBase64` - Create a new base64 string from the input. 
+* `FromBase64` - Create a new text string from a base64 input.
+* `ToJson` - Convert the input string to valid JSON.
+* `ToSha1` - Create a SHA-1 hash of the input string.
+* `ToSha256` - Create a SHA-256 hash of the input string.
+* `ToSha512` - Create a SHA-512 hash of the input string.
+* `ToAdler32` - Create an Adler32 hash of the input string.
+
+```yaml {label="stringConvert"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["FIELD1-TEXT"]
+    transforms:
+      - type: string
+        string:
+          type: Convert
+          convert: "ToUpper"
+```
+
+#### String format
+
+The `type: format` applies [Go string formatting](https://pkg.go.dev/fmt) to the
+input. 
+
+```yaml {label="typeFormat"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.field1
+    toFieldPath: metadata.annotations["stringAnnotation"]
+    transforms:
+      - type: string
+        string:
+          type: Format
+          fmt: "the-field-%s"
+```
+
+#### Join
+
+The `type: Join` joins all values in the input array into a string using the
+given separator.
+
+This transform only works with array inputs.
+
+```yaml {label="typeJoin"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.parameters.inputList
+    toFieldPath: spec.targetJoined
+    transforms:
+      - type: string
+        string:
+          type: Join
+          join:
+            separator: ","
+```
+
+#### Regular expression type
+
+The `type: Regexp` extracts the part of the input matching a regular expression. 
+
+Optionally use a `group` to match a regular expression capture group.  
+By default Crossplane matches the entire regular expression.
+
+```yaml {label="typeRegex"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: metadata.annotations["euRegion"]
+    transforms:
+      - type: string
+        string:
+          type: Regexp
+          regexp:
+            match: '^eu-(.*)-'
+            group: 1
+```
+
+#### Trim prefix
+
+The `type: TrimPrefix` uses 
+Go's [TrimPrefix](https://pkg.go.dev/strings#TrimPrefix) and removes characters 
+from the beginning of a line.
+
+```yaml {label="typeTrimP"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: metadata.annotations["north-1"]
+    transforms:
+      - type: string
+        string:
+          type: TrimPrefix
+          trim: `eu-
+```
+
+#### Trim suffix
+
+The `type: TrimSuffix` uses 
+Go's [TrimSuffix](https://pkg.go.dev/strings#TrimSuffix) and removes characters 
+from the end of a line.
+
+```yaml {label="typeTrimS"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: metadata.annotations["eu"]
+    transforms:
+      - type: string
+        string:
+          type: TrimSuffix
+          trim: `-north-1'
+```
+
+## Patch policies
+
+Crossplane supports two types of patch policies:
+* `fromFieldPath`
+* `toFieldPath`
+
+<!-- vale Google.Headings = NO -->
+### fromFieldPath policy
+<!-- vale Google.Headings = YES -->
+
+Using a `fromFieldPath: Required` policy on a patch requires the `fromFieldPath`
+to exist in the data source resource.
+
+{{<hint "tip" >}}
+If a resource patch isn't working applying the `fromFieldPath: Required` policy
+may produce an error in the composite resource to help troubleshoot. 
+{{< /hint >}}
+
+By default, Crossplane applies the policy `fromFieldPath: Optional`. With
+`fromFieldPath: Optional` Crossplane ignores a patch if the `fromFieldPath`
+doesn't exist.   
+
+With `fromFieldPath: Required` the composite resource produces an error if the
+`fromFieldPath` doesn't exist. 
+
+```yaml {label="required"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: metadata.annotations["eu"]
+    policy:
+      fromFieldPath: Required
+```
+
+<!-- vale Google.Headings = NO -->
+### toFieldPath policy
+<!-- vale Google.Headings = YES -->
+
+By default when applying a patch the destination data is replaced. Use
+`toFieldPath` to allow patches to merge arrays and objects without overwriting
+them.
+
+The `toFieldPath` policy supports these options:
+{{< table "table table-hover" >}}
+| Policy | Action |
+| ---  | --- |
+| `Replace` (default) | Replace the value at `toFieldPath`. | 
+| `MergeObjects` | Recursively merge into the value at `toFieldPath`. Keep any conflicting object keys. | 
+| `ForceMergeObjects` | Recursively merge into the value at `toFieldPath`. Replace any conflicting object keys. | 
+| `MergeObjectsAppendArrays` | Like `MergeObjects`, but append values to arrays instead of replacing them. | 
+| `ForceMergeObjectsAppendArrays` | Like `ForceMergeObjects`, but append values to arrays instead of replacing them. | 
+{{< /table >}}
+
+```yaml {label="merge"}
+patches:
+  - type: FromCompositeFieldPath
+    fromFieldPath: spec.desiredRegion
+    toFieldPath: metadata.annotations["eu"]
+    policy:
+      toFieldPath: MergeObjectsAppendArrays
+```
+
+## Connection Details
+
+Function patch and Transform must define the specific secret keys a resource
+creates with the `connectionDetails` object.
+
+{{<table "table table-sm" >}}
+| Secret Type | Description | 
+| --- | --- | 
+| `FromConnectionSecretKey` | Create a secret key matching the key of a secret generated by the resource. | 
+| `FromFieldPath`  | Create a secret key matching a field path of the resource. |
+| `FromValue`  | Create a secret key with a predefined value. |
+{{< /table >}}
+
+{{<hint "note">}}
+The `value` type must use a string value.  
+
+The `value` isn't added to the individual resource secret object. The `value`
+only appears in the combined composite resource secret.
+{{< /hint >}}
+
+```yaml {label="conDeet",copy-lines="none"}
+kind: Composition
+spec:
+  writeConnectionSecretsToNamespace: other-namespace
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+      - name: key
+        base:
+          # Removed for brevity
+          spec:
+            forProvider:
+            # Removed for brevity
+            writeConnectionSecretToRef:
+              namespace: docs
+              name: key1
+        connectionDetails:
+          - name: my-username
+            type: FromConnectionSecretKey
+            fromConnectionSecretKey: username
+          - name: my-field-secret
+            type: FromFieldPath
+            fromFieldPath: spec.forProvider.user
+          - name: my-status-secret
+            type: FromValue
+            value: "docs.crossplane.io"
+```
+
+The `connectionDetails` in a resource can reference a secret from a resource
+with `FromConnectionSecretKey`, from another field in the resource with
+`FromFieldPath` or a statically defined value with `FromValue`.
+
+Crossplane sets the secret key to the `name` value. 
+
+Describe the secret to view the secret keys inside the secret object.
+
+{{<hint "tip" >}}
+If more than one resource generates secrets with the same secret key name,
+Crossplane only saves one value. 
+
+Use a custom `name` to create unique secret keys.
+{{< /hint >}}
+
+{{<hint "important">}}
+Crossplane only adds connection details listed in the `connectionDetails` to the
+combined secret object.  
+
+Any connection secrets in a managed resource, not defined in the
+`connectionDetails` aren't added to the combined secret object.   
+{{< /hint >}}
+
+
+```shell {copy-lines="1"}
+kubectl describe secret
+Name:         my-access-key-secret
+Namespace:    default
+Labels:       <none>
+Annotations:  <none>
+
+Type:  connection.crossplane.io/v1alpha1
+
+Data
+====
+myUsername:      20 bytes
+myFieldSecret:   24 bytes
+myStaticSecret:  18 bytes
+```
+
+{{<hint "note" >}}
+The CompositeResourceDefinition can also limit which keys Crossplane stores from
+the composite resources.  
+
+By default an XRD writes all secret keys listed in the composed resources
+`connectionDetails` to the combined secret object.
+
+Read the 
+[CompositeResourceDefinition documentation]({{<ref "../concepts/composite-resource-definitions#manage-connection-secrets">}}) 
+for more information on restricting secret keys.
+{{< /hint >}}
+
+For more information on connection secrets read the 
+[Connection Secrets concepts age]({{<ref "../concepts/connection-details">}}).
+
+## Resource readiness checks
+
+By default Crossplane considers a composite resource or Claim as `READY` when
+the status of all created resource are `Type: Ready` and `Status: True`
+
+Some resources, for example, a ProviderConfig, don't have a Kubernetes status
+and are never considered `Ready`.
+
+Custom readiness checks allow Compositions to define what custom conditions to
+meet for a resource to be `Ready`.
+
+{{< hint "tip" >}}
+Use multiple readiness checks if a resource must meet multiple conditions for it
+to be `Ready`.
+{{< /hint >}}
+
+<!-- vale Google.WordList = NO -->
+Define a custom readiness check with the `readinessChecks` field on a resource.
+<!-- vale Google.WordList = YES -->
+
+Checks have a `type` defining how to match the resource and a `fieldPath` of
+which field in the resource to compare.
+
+```yaml {label="check",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: <match type>
+      fieldPath: <resource field>
+```
+
+Compositions support matching resource fields by:
+ * [string match](#match-a-string)
+ * [integer match](#match-an-integer)
+ * [non-empty match](#match-that-a-field-exists)
+ * [always ready](#always-consider-a-resource-ready)
+ * [condition match](#match-a-condition)
+ * [boolean match](#match-a-boolean)
+
+### Match a string
+
+`MatchString` considers the composed resource to be ready when the value of a
+field in that resource matches a specified string.
+
+{{<hint "note" >}}
+<!-- vale Google.WordList = NO -->
+Crossplane only supports exact string matches. Substrings and regular
+expressions aren't supported in a readiness check.
+<!-- vale Google.WordList = YES -->
+{{</hint >}}
+
+
+For example, matching the string `Online` in the resource's
+`status.atProvider.state` field. 
+
+```yaml {label="matchstring",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: MatchString
+      fieldPath: status.atProvider.state
+      matchString: "Online"
+```
+
+### Match an integer
+
+`MatchInteger` considers the composed resource to be ready when the value of a
+field in that resource matches a specified integer.
+
+{{<hint "note" >}}
+<!-- vale Google.WordList = NO -->
+Crossplane doesn't support matching `0`. 
+<!-- vale Google.WordList = YES -->
+{{</hint >}}
+
+For example, matching the number `4` in the resource's `status.atProvider.state`
+field. 
+
+```yaml {label="matchint",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: MatchInteger
+      fieldPath: status.atProvider.state
+      matchInteger: 4
+```
+
+### Match that a field exists
+`NonEmpty` considers the composed resource to be ready when a field exists with
+a value. 
+
+{{<hint "note" >}}
+<!-- vale Google.WordList = NO -->
+Crossplane considers a value of `0` or an empty string as empty.
+{{</hint >}}
+
+For example, to check that a resource's `status.atProvider.state` field isn't
+empty. 
+<!-- vale Google.WordList = YES -->
+
+```yaml {label="NonEmpty",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: NonEmpty
+      fieldPath: status.atProvider.state
+```
+
+{{<hint "tip" >}}
+Checking `NonEmpty` doesn't
+require setting any other fields.
+{{< /hint >}} 
+
+### Always consider a resource ready
+`None` considers the composed resource to be ready as soon as it's created.
+Crossplane doesn't wait for any other conditions before declaring the resource
+ready. 
+
+For example, consider `my-resource` ready as soon as it's created.
+
+
+```yaml {label="none",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: None
+```
+
+### Match a condition
+`Condition` considers the composed resource to be ready when it finds the
+expected condition type, with the expected status for it in its
+`status.conditions`.
+
+For example, consider `my-resource`, which is ready if there is a condition of
+type `MyType` with a status of `Success`.
+
+```yaml {label="condition",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: MatchCondition
+      matchCondition:
+        type: MyType
+        status: Success
+```
+
+### Match a boolean
+
+Two types of checks exist for matching boolean fields:
+ * `MatchTrue`
+ * `MatchFalse`
+
+`MatchTrue` considers the composed resource to be ready when the value of a 
+field inside that resource is `true`.
+
+`MatchFalse` considers the composed resource to be ready when the value of a 
+field inside that resource is `false`.
+
+For example, consider 
+`my-resource`, which is
+ready if 
+` status.atProvider.manifest.status.ready`
+is `true`.
+
+```yaml {label="matchTrue",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: MatchTrue
+      fieldPath: status.atProvider.manifest.status.ready
+```
+{{<hint "tip" >}}
+Checking `MatchTrue` doesn't
+require setting any other fields.
+{{< /hint >}} 
+
+`MatchFalse` matches fields that express readiness with the value `false`.
+
+For example, consider `my-resource`, is ready if `
+status.atProvider.manifest.status.pending` is `false`.
+
+```yaml {label="matchFalse",copy-lines="none"}
+apiVersion: pt.fn.crossplane.io/v1beta1
+kind: Resources
+resources:
+- name: my-resource
+  base:
+    # Removed for brevity
+  readinessChecks:
+    - type: MatchFalse
+      fieldPath: status.atProvider.manifest.status.pending
+```
+
+{{<hint "tip" >}}
+Checking `MatchFalse` doesn't require setting any other fields.
+{{< /hint >}} 
\ No newline at end of file
diff --git a/content/master/guides/vault-as-secret-store.md b/content/master/guides/vault-as-secret-store.md
index d76ceb97..6116bd05 100644
--- a/content/master/guides/vault-as-secret-store.md
+++ b/content/master/guides/vault-as-secret-store.md
@@ -411,35 +411,47 @@ spec:
   compositeTypeRef:
     apiVersion: ess.example.org/v1alpha1
     kind: CompositeESSInstance
-  resources:
-    - name: serviceaccount
-      base:
-        apiVersion: iam.gcp.crossplane.io/v1alpha1
-        kind: ServiceAccount
-        metadata:
-          name: ess-test-sa
-        spec:
-          forProvider:
-            displayName: a service account to test ess
-    - name: serviceaccountkey
-      base:
-        apiVersion: iam.gcp.crossplane.io/v1alpha1
-        kind: ServiceAccountKey
-        spec:
-          forProvider:
-            serviceAccountSelector:
-              matchControllerRef: true
-          publishConnectionDetailsTo:
-            name: ess-mr-conn
+  mode: Pipeline
+  pipeline:
+  - step: patch-and-transform
+    functionRef:
+      name: function-patch-and-transform
+    input:
+      apiVersion: pt.fn.crossplane.io/v1beta1
+      kind: Resources
+      resources:
+        - name: serviceaccount
+          base:
+            apiVersion: iam.gcp.crossplane.io/v1alpha1
+            kind: ServiceAccount
             metadata:
-              labels:
-                environment: development
-                team: backend
-            configRef:
-              name: vault
-      connectionDetails:
-        - fromConnectionSecretKey: publicKey
-        - fromConnectionSecretKey: publicKeyType" | kubectl apply -f -
+              name: ess-test-sa
+            spec:
+              forProvider:
+                displayName: a service account to test ess
+        - name: serviceaccountkey
+          base:
+            apiVersion: iam.gcp.crossplane.io/v1alpha1
+            kind: ServiceAccountKey
+            spec:
+              forProvider:
+                serviceAccountSelector:
+                  matchControllerRef: true
+              publishConnectionDetailsTo:
+                name: ess-mr-conn
+                metadata:
+                  labels:
+                    environment: development
+                    team: backend
+                configRef:
+                  name: vault
+          connectionDetails:
+            - name: publicKey
+              type: FromConnectionSecretKey
+              fromConnectionSecretKey: publicKey
+            - name: publicKey
+              type: FromConnectionSecretKey
+              fromConnectionSecretKey: publicKeyType" | kubectl apply -f -
 ```
 
 ### Create a Claim
diff --git a/content/master/guides/write-a-composition-function-in-go.md b/content/master/guides/write-a-composition-function-in-go.md
index 4fd5aa30..402dd93f 100644
--- a/content/master/guides/write-a-composition-function-in-go.md
+++ b/content/master/guides/write-a-composition-function-in-go.md
@@ -1,8 +1,5 @@
 ---
 title: Write a Composition Function in Go
-state: beta
-alphaVersion: "1.11"
-betaVersion: "1.14"
 weight: 80
 description: "Composition functions allow you to template resources using Go"
 ---
@@ -11,7 +8,7 @@ Composition functions (or just functions, for short) are custom programs that
 template Crossplane resources. Crossplane calls composition functions to
 determine what resources it should create when you create a composite resource
 (XR). Read the
-[concepts]({{<ref "../concepts/composition-functions" >}})
+[concepts]({{<ref "../concepts/compositions" >}})
 page to learn more about composition functions.
 
 You can write a function to template resources using a general purpose
@@ -22,7 +19,7 @@ conditionals. This guide explains how to write a composition function in
 
 {{< hint "important" >}}
 It helps to be familiar with
-[how composition functions work]({{<ref "../concepts/composition-functions#how-composition-functions-work" >}})
+[how composition functions work]({{<ref "../concepts/compositions#how-composition-functions-work" >}})
 before following this guide.
 {{< /hint >}}
 
@@ -79,17 +76,17 @@ build or test a composition function.
 
 ## Initialize the function from a template
 
-Use the `crossplane beta xpkg init` command to initialize a new function. When
+Use the `crossplane xpkg init` command to initialize a new function. When
 you run this command it initializes your function using
 [a GitHub repository](https://github.com/crossplane/function-template-go)
 as a template.
 
 ```shell {copy-lines=1}
-crossplane beta xpkg init function-xbuckets function-template-go -d function-xbuckets 
+crossplane xpkg init function-xbuckets function-template-go -d function-xbuckets 
 Initialized package "function-xbuckets" in directory "/home/negz/control/negz/function-xbuckets" from https://github.com/crossplane/function-template-go/tree/91a1a5eed21964ff98966d72cc6db6f089ad63f4 (main)
 ```
 
-The `crossplane beta init xpkg` command creates a directory named
+The `crossplane xpkg init` command creates a directory named
 `function-xbuckets`. When you run the command the new directory should look like
 this:
 
@@ -111,7 +108,7 @@ some other files in the template:
 <!--
 This tip talks about future plans for Crossplane.
 -->
-In v1.14 of the Crossplane CLI `crossplane beta xpkg init` just clones a
+In v1.14 of the Crossplane CLI `crossplane xpkg init` just clones a
 template GitHub repository. A future CLI release will automate tasks like
 replacing the template name with the new function's name. See Crossplane issue
 [#4941](https://github.com/crossplane/crossplane/issues/4941) for details.
@@ -134,7 +131,7 @@ should delete the `input` and `package/input` directories.
 
 The `input` directory defines a Go struct that a function can use to take input,
 using the `input` field from a Composition. The
-[composition functions]({{<ref "../concepts/composition-functions" >}})
+[composition functions]({{<ref "../concepts/compositions" >}})
 documentation explains how to pass an input to a composition function.
 
 The `package/input` directory contains an OpenAPI schema generated from the
@@ -163,7 +160,7 @@ method in `fn.go`. When you first open the file it contains a "hello world"
 function.
 
 ```go {label="hello-world"}
-func (f *Function) RunFunction(_ context.Context, req *fnv1beta1.RunFunctionRequest) (*fnv1beta1.RunFunctionResponse, error) {
+func (f *Function) RunFunction(_ context.Context, req *fnv1.RunFunctionRequest) (*fnv1.RunFunctionResponse, error) {
 	f.log.Info("Running Function", "tag", req.GetMeta().GetTag())
 
 	rsp := response.To(req, response.DefaultTTL)
@@ -190,13 +187,13 @@ The function tells Crossplane what resources it should compose by returning a
 Crossplane generates the `RunFunctionRequest` and `RunFunctionResponse` structs
 using [Protocol Buffers](http://protobuf.dev). You can find detailed schemas for
 `RunFunctionRequest` and `RunFunctionResponse` in the
-[Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1beta1).
+[Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1).
 {{</hint>}}
 
 Edit the `RunFunction` method to replace it with this code.
 
 ```go {hl_lines="4-56"}
-func (f *Function) RunFunction(_ context.Context, req *fnv1beta1.RunFunctionRequest) (*fnv1beta1.RunFunctionResponse, error) {
+func (f *Function) RunFunction(_ context.Context, req *fnv1.RunFunctionRequest) (*fnv1.RunFunctionResponse, error) {
 	rsp := response.To(req, response.DefaultTTL)
 
 	xr, err := request.GetObservedCompositeResource(req)
@@ -274,7 +271,7 @@ import (
 
 	"github.com/crossplane/function-sdk-go/errors"
 	"github.com/crossplane/function-sdk-go/logging"
-	fnv1beta1 "github.com/crossplane/function-sdk-go/proto/v1beta1"
+	fnv1 "github.com/crossplane/function-sdk-go/proto/v1"
 	"github.com/crossplane/function-sdk-go/request"
 	"github.com/crossplane/function-sdk-go/resource"
 	"github.com/crossplane/function-sdk-go/resource/composed"
@@ -283,14 +280,14 @@ import (
 
 // Function returns whatever response you ask it to.
 type Function struct {
-	fnv1beta1.UnimplementedFunctionRunnerServiceServer
+	fnv1.UnimplementedFunctionRunnerServiceServer
 
 	log logging.Logger
 }
 
 // RunFunction observes an XBuckets composite resource (XR). It adds an S3
 // bucket to the desired state for every entry in the XR's spec.names array.
-func (f *Function) RunFunction(_ context.Context, req *fnv1beta1.RunFunctionRequest) (*fnv1beta1.RunFunctionResponse, error) {
+func (f *Function) RunFunction(_ context.Context, req *fnv1.RunFunctionRequest) (*fnv1.RunFunctionResponse, error) {
 	f.log.Info("Running Function", "tag", req.GetMeta().GetTag())
 
 	// Create a response to the request. This copies the desired state and
@@ -428,8 +425,8 @@ for the SDK.
 
 ## Test the function end-to-end
 
-Test your function by adding unit tests, and by using the `crossplane beta
-render` command.
+Test your function by adding unit tests, and by using the `crossplane render`
+command.
 
 Go has rich support for unit testing. When you initialize a function from the
 template it adds some unit tests to `fn_test.go`. These tests follow Go's
@@ -456,17 +453,17 @@ import (
 
 	"github.com/crossplane/crossplane-runtime/pkg/logging"
 
-	fnv1beta1 "github.com/crossplane/function-sdk-go/proto/v1beta1"
+	fnv1 "github.com/crossplane/function-sdk-go/proto/v1"
 	"github.com/crossplane/function-sdk-go/resource"
 )
 
 func TestRunFunction(t *testing.T) {
 	type args struct {
 		ctx context.Context
-		req *fnv1beta1.RunFunctionRequest
+		req *fnv1.RunFunctionRequest
 	}
 	type want struct {
-		rsp *fnv1beta1.RunFunctionResponse
+		rsp *fnv1.RunFunctionResponse
 		err error
 	}
 
@@ -478,9 +475,9 @@ func TestRunFunction(t *testing.T) {
 		"AddTwoBuckets": {
 			reason: "The Function should add two buckets to the desired composed resources",
 			args: args{
-				req: &fnv1beta1.RunFunctionRequest{
-					Observed: &fnv1beta1.State{
-						Composite: &fnv1beta1.Resource{
+				req: &fnv1.RunFunctionRequest{
+					Observed: &fnv1.State{
+						Composite: &fnv1.Resource{
 							// MustStructJSON is a handy way to provide mock
 							// resources.
 							Resource: resource.MustStructJSON(`{
@@ -502,10 +499,10 @@ func TestRunFunction(t *testing.T) {
 				},
 			},
 			want: want{
-				rsp: &fnv1beta1.RunFunctionResponse{
-					Meta: &fnv1beta1.ResponseMeta{Ttl: durationpb.New(60 * time.Second)},
-					Desired: &fnv1beta1.State{
-						Resources: map[string]*fnv1beta1.Resource{
+				rsp: &fnv1.RunFunctionResponse{
+					Meta: &fnv1.ResponseMeta{Ttl: durationpb.New(60 * time.Second)},
+					Desired: &fnv1.State{
+						Resources: map[string]*fnv1.Resource{
 							"xbuckets-test-bucket-a": {Resource: resource.MustStructJSON(`{
 								"apiVersion": "s3.aws.upbound.io/v1beta1",
 								"kind": "Bucket",
@@ -582,7 +579,7 @@ Expand the following block to see example files.
 
 {{<expand "The xr.yaml, composition.yaml and function.yaml files">}}
 
-You can recreate the output below using by running `crossplane beta render` with
+You can recreate the output below using by running `crossplane render` with
 these files.
 
 The `xr.yaml` file contains the composite resource to render:
@@ -627,7 +624,7 @@ The `functions.yaml` file contains the Functions the Composition references in
 its pipeline steps:
 
 ```yaml
-apiVersion: pkg.crossplane.io/v1beta1
+apiVersion: pkg.crossplane.io/v1
 kind: Function
 metadata:
   name: function-xbuckets
@@ -642,12 +639,12 @@ spec:
 
 The Function in `functions.yaml` uses the
 {{<hover label="development" line="6">}}Development{{</hover>}}
-runtime. This tells `crossplane beta render` that your function is running
+runtime. This tells `crossplane render` that your function is running
 locally. It connects to your locally running function instead of using Docker to
 pull and run the function.
 
 ```yaml {label="development"}
-apiVersion: pkg.crossplane.io/v1beta1
+apiVersion: pkg.crossplane.io/v1
 kind: Function
 metadata:
   name: function-xbuckets
@@ -667,10 +664,10 @@ to run without encryption or authentication. Only use it during testing and
 development.
 {{</hint>}}
 
-In a separate terminal, run `crossplane beta render`. 
+In a separate terminal, run `crossplane render`. 
 
 ```shell
-crossplane beta render xr.yaml composition.yaml functions.yaml
+crossplane render xr.yaml composition.yaml functions.yaml
 ```
 
 This command calls your function. In the terminal where your function is running
@@ -682,7 +679,7 @@ go run . --insecure --debug
 2023-10-31T16:17:32.159-0700    INFO    function-xbuckets/fn.go:125     Added desired buckets   {"xr-version": "example.crossplane.io/v1", "xr-kind": "XBuckets", "xr-name": "example-buckets", "region": "us-east-2", "count": 3}
 ```
 
-The `crossplane beta render` command prints the desired resources the function
+The `crossplane render` command prints the desired resources the function
 returns.
 
 ```yaml
@@ -740,7 +737,7 @@ spec:
 
 {{<hint "tip">}}
 Read the composition functions documentation to learn more about
-[testing composition functions]({{< ref "../concepts/composition-functions#test-a-composition-that-uses-functions" >}}).
+[testing composition functions]({{< ref "../concepts/compositions#test-a-composition-that-uses-functions" >}}).
 {{</hint>}}
 
 ## Build and push the function to a package registry
@@ -757,7 +754,7 @@ then pushing all the packages to a single tag in the registry.
 
 Pushing your function to a registry allows you to use your function in a
 Crossplane control plane. See the
-[composition functions documentation]({{<ref "../concepts/composition-functions" >}}).
+[composition functions documentation]({{<ref "../concepts/compositions" >}}).
 to learn how to use a function in a control plane.
 
 Use Docker to build a runtime for each platform.
diff --git a/content/master/guides/write-a-composition-function-in-python.md b/content/master/guides/write-a-composition-function-in-python.md
index ea030f01..caa40269 100644
--- a/content/master/guides/write-a-composition-function-in-python.md
+++ b/content/master/guides/write-a-composition-function-in-python.md
@@ -1,8 +1,5 @@
 ---
 title: Write a Composition Function in Python
-state: beta
-alphaVersion: "1.11"
-betaVersion: "1.14"
 weight: 81
 description: "Composition functions allow you to template resources using Python"
 ---
@@ -11,7 +8,7 @@ Composition functions (or just functions, for short) are custom programs that
 template Crossplane resources. Crossplane calls composition functions to
 determine what resources it should create when you create a composite resource
 (XR). Read the
-[concepts]({{<ref "../concepts/composition-functions" >}})
+[concepts]({{<ref "../concepts/compositions" >}})
 page to learn more about composition functions.
 
 You can write a function to template resources using a general purpose
@@ -22,7 +19,7 @@ conditionals. This guide explains how to write a composition function in
 
 {{< hint "important" >}}
 It helps to be familiar with
-[how composition functions work]({{<ref "../concepts/composition-functions#how-composition-functions-work" >}})
+[how composition functions work]({{<ref "../concepts/compositions#how-composition-functions-work" >}})
 before following this guide.
 {{< /hint >}}
 
@@ -80,17 +77,17 @@ build or test a composition function.
 
 ## Initialize the function from a template
 
-Use the `crossplane beta xpkg init` command to initialize a new function. When
+Use the `crossplane xpkg init` command to initialize a new function. When
 you run this command it initializes your function using
 [a GitHub repository](https://github.com/crossplane/function-template-python)
 as a template.
 
 ```shell {copy-lines=1}
-crossplane beta xpkg init function-xbuckets https://github.com/crossplane/function-template-python -d function-xbuckets
+crossplane xpkg init function-xbuckets https://github.com/crossplane/function-template-python -d function-xbuckets
 Initialized package "function-xbuckets" in directory "/home/negz/control/negz/function-xbuckets" from https://github.com/crossplane/function-template-python/tree/bfed6923ab4c8e7adeed70f41138645fc7d38111 (main)
 ```
 
-The `crossplane beta init xpkg` command creates a directory named
+The `crossplane xpkg init` command creates a directory named
 `function-xbuckets`. When you run the command the new directory should look like
 this:
 
@@ -118,7 +115,7 @@ know about some other files in the template:
 <!--
 This tip talks about future plans for Crossplane.
 -->
-In v1.14 of the Crossplane CLI `crossplane beta xpkg init` just clones a
+In v1.14 of the Crossplane CLI `crossplane xpkg init` just clones a
 template GitHub repository. A future CLI release will automate tasks like
 replacing the template name with the new function's name. See Crossplane issue
 [#4941](https://github.com/crossplane/crossplane/issues/4941) for details.
@@ -132,7 +129,7 @@ The `package/input` directory defines the OpenAPI schema for the a function's
 input. The function in this guide doesn't accept an input. Delete the
 `package/input` directory.   
 
-The [composition functions]({{<ref "../concepts/composition-functions" >}})
+The [composition functions]({{<ref "../concepts/compositions" >}})
 documentation explains composition function inputs.
 
 {{<hint "tip">}}
@@ -151,7 +148,7 @@ method in `function/fn.py`. When you first open the file it contains a "hello
 world" function.
 
 ```python {label="hello-world"}
-async def RunFunction(self, req: fnv1beta1.RunFunctionRequest, _: grpc.aio.ServicerContext) -> fnv1beta1.RunFunctionResponse:
+async def RunFunction(self, req: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext) -> fnv1.RunFunctionResponse:
     log = self.log.bind(tag=req.meta.tag)
     log.info("Running function")
 
@@ -178,7 +175,7 @@ The function tells Crossplane what resources it should compose by returning a
 Edit the `RunFunction` method to replace it with this code.
 
 ```python {hl_lines="7-28"}
-async def RunFunction(self, req: fnv1beta1.RunFunctionRequest, _: grpc.aio.ServicerContext) -> fnv1beta1.RunFunctionResponse:
+async def RunFunction(self, req: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext) -> fnv1.RunFunctionResponse:
     log = self.log.bind(tag=req.meta.tag)
     log.info("Running function")
 
@@ -219,11 +216,11 @@ commentary explaining the function's logic.
 
 import grpc
 from crossplane.function import logging, response
-from crossplane.function.proto.v1beta1 import run_function_pb2 as fnv1beta1
-from crossplane.function.proto.v1beta1 import run_function_pb2_grpc as grpcv1beta1
+from crossplane.function.proto.v1 import run_function_pb2 as fnv1
+from crossplane.function.proto.v1 import run_function_pb2_grpc as grpcv1
 
 
-class FunctionRunner(grpcv1beta1.FunctionRunnerService):
+class FunctionRunner(grpcv1.FunctionRunnerService):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
     def __init__(self):
@@ -231,8 +228,8 @@ class FunctionRunner(grpcv1beta1.FunctionRunnerService):
         self.log = logging.get_logger()
 
     async def RunFunction(
-        self, req: fnv1beta1.RunFunctionRequest, _: grpc.aio.ServicerContext
-    ) -> fnv1beta1.RunFunctionResponse:
+        self, req: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext
+    ) -> fnv1.RunFunctionResponse:
         """Run the function."""
         # Create a logger for this request.
         log = self.log.bind(tag=req.meta.tag)
@@ -257,7 +254,7 @@ class FunctionRunner(grpcv1beta1.FunctionRunnerService):
             # the key and mutate its value as if it did exist.
             #
             # The below code works because accessing the xbuckets-{name} key
-            # automatically creates a new, empty fnv1beta1.Resource message. The
+            # automatically creates a new, empty fnv1.Resource message. The
             # Resource message has a resource field containing an empty Struct
             # object that can be populated from a dictionary by calling update.
             #
@@ -308,7 +305,7 @@ Read [the Python Function SDK documentation](https://crossplane.github.io/functi
 The Python SDK automatically generates the `RunFunctionRequest` and
 `RunFunctionResponse` Python objects from a
 [Protocol Buffers](https://protobuf.dev) schema. You can see the schema in the
-[Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1beta1).
+[Buf Schema Registry](https://buf.build/crossplane/crossplane/docs/main:apiextensions.fn.proto.v1).
 
 The fields of the generated Python objects behave similarly to builtin Python
 types like dictionaries and lists. Be aware that there are some differences.
@@ -321,7 +318,7 @@ Instead of adding a new resource like this:
 
 ```python
 resource = {"apiVersion": "example.org/v1", "kind": "Composed", ...}
-rsp.desired.resources["new-resource"] = fnv1beta1.Resource(resource=resource)
+rsp.desired.resources["new-resource"] = fnv1.Resource(resource=resource)
 ```
 
 Pretend it already exists and mutate it, like this:
@@ -338,8 +335,8 @@ for further details.
 
 ## Test the function end-to-end
 
-Test your function by adding unit tests, and by using the `crossplane beta
-render` command.
+Test your function by adding unit tests, and by using the `crossplane render`
+command.
 
 When you initialize a function from the
 template it adds some unit tests to `tests/test_fn.py`. These tests use the
@@ -355,7 +352,7 @@ import dataclasses
 import unittest
 
 from crossplane.function import logging, resource
-from crossplane.function.proto.v1beta1 import run_function_pb2 as fnv1beta1
+from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 from google.protobuf import duration_pb2 as durationpb
 from google.protobuf import json_format
 from google.protobuf import struct_pb2 as structpb
@@ -372,15 +369,15 @@ class TestFunctionRunner(unittest.IsolatedAsyncioTestCase):
         @dataclasses.dataclass
         class TestCase:
             reason: str
-            req: fnv1beta1.RunFunctionRequest
-            want: fnv1beta1.RunFunctionResponse
+            req: fnv1.RunFunctionRequest
+            want: fnv1.RunFunctionResponse
 
         cases = [
             TestCase(
                 reason="The function should compose two S3 buckets.",
-                req=fnv1beta1.RunFunctionRequest(
-                    observed=fnv1beta1.State(
-                        composite=fnv1beta1.Resource(
+                req=fnv1.RunFunctionRequest(
+                    observed=fnv1.State(
+                        composite=fnv1.Resource(
                             resource=resource.dict_to_struct(
                                 {
                                     "apiVersion": "example.crossplane.io/v1alpha1",
@@ -395,11 +392,11 @@ class TestFunctionRunner(unittest.IsolatedAsyncioTestCase):
                         )
                     )
                 ),
-                want=fnv1beta1.RunFunctionResponse(
-                    meta=fnv1beta1.ResponseMeta(ttl=durationpb.Duration(seconds=60)),
-                    desired=fnv1beta1.State(
+                want=fnv1.RunFunctionResponse(
+                    meta=fnv1.ResponseMeta(ttl=durationpb.Duration(seconds=60)),
+                    desired=fnv1.State(
                         resources={
-                            "xbuckets-test-bucket-a": fnv1beta1.Resource(
+                            "xbuckets-test-bucket-a": fnv1.Resource(
                                 resource=resource.dict_to_struct(
                                     {
                                         "apiVersion": "s3.aws.upbound.io/v1beta1",
@@ -415,7 +412,7 @@ class TestFunctionRunner(unittest.IsolatedAsyncioTestCase):
                                     }
                                 )
                             ),
-                            "xbuckets-test-bucket-b": fnv1beta1.Resource(
+                            "xbuckets-test-bucket-b": fnv1.Resource(
                                 resource=resource.dict_to_struct(
                                     {
                                         "apiVersion": "s3.aws.upbound.io/v1beta1",
@@ -482,7 +479,7 @@ Expand the following block to see example files.
 
 {{<expand "The xr.yaml, composition.yaml and function.yaml files">}}
 
-You can recreate the output below using by running `crossplane beta render` with
+You can recreate the output below using by running `crossplane render` with
 these files.
 
 The `xr.yaml` file contains the composite resource to render:
@@ -527,7 +524,7 @@ The `functions.yaml` file contains the Functions the Composition references in
 its pipeline steps:
 
 ```yaml
-apiVersion: pkg.crossplane.io/v1beta1
+apiVersion: pkg.crossplane.io/v1
 kind: Function
 metadata:
   name: function-xbuckets
@@ -542,12 +539,12 @@ spec:
 
 The Function in `functions.yaml` uses the
 {{<hover label="development" line="6">}}Development{{</hover>}}
-runtime. This tells `crossplane beta render` that your function is running
+runtime. This tells `crossplane render` that your function is running
 locally. It connects to your locally running function instead of using Docker to
 pull and run the function.
 
 ```yaml {label="development"}
-apiVersion: pkg.crossplane.io/v1beta1
+apiVersion: pkg.crossplane.io/v1
 kind: Function
 metadata:
   name: function-xbuckets
@@ -566,10 +563,10 @@ hatch run development
 Only use it during testing and development.
 {{</hint>}}
 
-In a separate terminal, run `crossplane beta render`. 
+In a separate terminal, run `crossplane render`. 
 
 ```shell
-crossplane beta render xr.yaml composition.yaml functions.yaml
+crossplane render xr.yaml composition.yaml functions.yaml
 ```
 
 This command calls your function. In the terminal where your function is running
@@ -581,7 +578,7 @@ hatch run development
 2024-01-11T22:12:58.153792Z [info     ] Added desired buckets          count=3 filename=fn.py lineno=68 region=us-east-2 tag=
 ```
 
-The `crossplane beta render` command prints the desired resources the function
+The `crossplane render` command prints the desired resources the function
 returns.
 
 ```yaml
@@ -639,7 +636,7 @@ spec:
 
 {{<hint "tip">}}
 Read the composition functions documentation to learn more about
-[testing composition functions]({{< ref "../concepts/composition-functions#test-a-composition-that-uses-functions" >}}).
+[testing composition functions]({{< ref "../concepts/compositions#test-a-composition-that-uses-functions" >}}).
 {{</hint>}}
 
 ## Build and push the function to a package registry
@@ -656,7 +653,7 @@ then pushing all the packages to a single tag in the registry.
 
 Pushing your function to a registry allows you to use your function in a
 Crossplane control plane. See the
-[composition functions documentation]({{<ref "../concepts/composition-functions" >}}).
+[composition functions documentation]({{<ref "../concepts/compositions" >}}).
 to learn how to use a function in a control plane.
 
 Use Docker to build a runtime for each platform.