docs: environmental configuration

docs/develop/dotnet/temporal-nexus.mdx

@@ -2,7 +2,7 @@
 id: nexus
 title: Temporal Nexus - .NET SDK Feature Guide
 sidebar_label: Temporal Nexus
-description: Use Temporal Nexus within the .NET SDK to connect Durable Executions within and across Namespaces using a Nexus Endpoint, a Nexus Service contract, and Nexus Operations.
+description: use Temporal Nexus within the .NET SDK to connect Durable Executions within and across Namespaces using a Nexus Endpoint, a Nexus Service contract, and Nexus Operations.
 toc_max_heading_level: 4
 keywords:
   - temporal

docs/develop/typescript/cancellation.mdx

@@ -9,56 +9,67 @@ tags:
   - Workflows
   - TypeScript SDK
   - Temporal SDKs
-description: Explore the power of Cancellation Scopes in TypeScript to manage nested, non-cancellable, and timeout-based operations within Temporal Workflows with ease.
+description:
+  Explore the power of Cancellation Scopes in TypeScript to manage nested, non-cancellable, and timeout-based operations
+  within Temporal Workflows with ease.
 ---
 
 ## Cancellation scopes in Typescript {#cancellation-scopes}
 
-In the TypeScript SDK, Workflows are represented internally by a tree of cancellation scopes, each with cancellation behaviors you can specify.
-By default, everything runs in the "root" scope.
+In the TypeScript SDK, Workflows are represented internally by a tree of cancellation scopes, each with cancellation
+behaviors you can specify. By default, everything runs in the "root" scope.
 
-Scopes are created using the [CancellationScope](https://typescript.temporal.io/api/classes/workflow.CancellationScope) constructor or one of three static helpers:
+Scopes are created using the [CancellationScope](https://typescript.temporal.io/api/classes/workflow.CancellationScope)
+constructor or one of three static helpers:
 
-- [cancellable(fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#cancellable-1): Children are automatically cancelled when their containing scope is cancelled.
+- [cancellable(fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#cancellable-1): Children are
+  automatically cancelled when their containing scope is cancelled.
   - Equivalent to `new CancellationScope().run(fn)`.
-- [nonCancellable(fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#noncancellable): Cancellation does not propagate to children.
+- [nonCancellable(fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#noncancellable):
+  Cancellation does not propagate to children.
   - Equivalent to `new CancellationScope({ cancellable: false }).run(fn)`.
-- [withTimeout(timeoutMs, fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#withtimeout): If a timeout triggers before `fn` resolves, the scope is cancelled, triggering cancellation of any enclosed operations, such as Activities and Timers.
+- [withTimeout(timeoutMs, fn)](https://typescript.temporal.io/api/classes/workflow.CancellationScope#withtimeout): If a
+  timeout triggers before `fn` resolves, the scope is cancelled, triggering cancellation of any enclosed operations,
+  such as Activities and Timers.
   - Equivalent to `new CancellationScope({ cancellable: true, timeout: timeoutMs }).run(fn)`.
 
-Cancellations are applied to cancellation scopes, which can encompass an entire Workflow or just part of one.
-Scopes can be nested, and cancellation propagates from outer scopes to inner ones.
-A Workflow's `main` function runs in the outermost scope.
-Cancellations are handled by catching `CancelledFailure`s thrown by cancelable operations.
+Cancellations are applied to cancellation scopes, which can encompass an entire Workflow or just part of one. Scopes can
+be nested, and cancellation propagates from outer scopes to inner ones. A Workflow's `main` function runs in the
+outermost scope. Cancellations are handled by catching `CancelledFailure`s thrown by cancelable operations.
 
-`CancellationScope.run()` and the static helpers mentioned earlier return native JavaScript promises, so you can use the familiar Promise APIs like `Promise.all` and `Promise.race` to model your asynchronous logic.
-You can also use the following APIs:
+`CancellationScope.run()` and the static helpers mentioned earlier return native JavaScript promises, so you can use the
+familiar Promise APIs like `Promise.all` and `Promise.race` to model your asynchronous logic. You can also use the
+following APIs:
 
 - `CancellationScope.current()`: Get the current scope.
 - `scope.cancel()`: Cancel all operations inside a `scope`.
 - `scope.run(fn)`: Run an async function within a `scope` and return the result of `fn`.
-- `scope.cancelRequested`: A promise that resolves when a scope cancellation is requested, such as when Workflow code calls `cancel()` or the entire Workflow is cancelled by an external client.
+- `scope.cancelRequested`: A promise that resolves when a scope cancellation is requested, such as when Workflow code
+  calls `cancel()` or the entire Workflow is cancelled by an external client.
 
-When a `CancellationScope` is cancelled, it propagates cancellation in any child scopes and of any cancelable operations created within it, such as the following:
+When a `CancellationScope` is cancelled, it propagates cancellation in any child scopes and of any cancelable operations
+created within it, such as the following:
 
 - Activities
 - Timers (created with the [sleep](https://typescript.temporal.io/api/namespaces/workflow#sleep) function)
 - [Triggers](https://typescript.temporal.io/api/classes/workflow.Trigger)
 
 ### CancelledFailure
 
-Timers and triggers throw [CancelledFailure](https://typescript.temporal.io/api/classes/common.CancelledFailure) when cancelled; Activities and Child Workflows throw `ActivityFailure` and `ChildWorkflowFailure` with cause set to `CancelledFailure`.
-One exception is when an Activity or Child Workflow is scheduled in an already cancelled scope (or Workflow).
-In this case, they propagate the `CancelledFailure` that was thrown to cancel the scope.
+Timers and triggers throw [CancelledFailure](https://typescript.temporal.io/api/classes/common.CancelledFailure) when
+cancelled; Activities and Child Workflows throw `ActivityFailure` and `ChildWorkflowFailure` with cause set to
+`CancelledFailure`. One exception is when an Activity or Child Workflow is scheduled in an already cancelled scope (or
+Workflow). In this case, they propagate the `CancelledFailure` that was thrown to cancel the scope.
 
-To simplify checking for cancellation, use the [isCancellation(err)](https://typescript.temporal.io/api/namespaces/workflow#iscancellation) function.
+To simplify checking for cancellation, use the
+[isCancellation(err)](https://typescript.temporal.io/api/namespaces/workflow#iscancellation) function.
 
 ### Internal cancellation example
 
 <!--SNIPSTART typescript-cancel-a-timer-from-workflow-->
 [packages/test/src/workflows/cancel-timer-immediately.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/cancel-timer-immediately.ts)
 ```ts
-import { CancelledFailure, CancellationScope, sleep } from '@temporalio/workflow';
+import { CancellationScope, CancelledFailure, sleep } from '@temporalio/workflow';
 
 export async function cancelTimer(): Promise<void> {
   // Timers and Activities are automatically cancelled when their containing scope is cancelled.
@@ -84,7 +95,7 @@ Alternatively, the preceding can be written as the following.
 <!--SNIPSTART typescript-cancel-a-timer-from-workflow-alternative-impl-->
 [packages/test/src/workflows/cancel-timer-immediately-alternative-impl.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/cancel-timer-immediately-alternative-impl.ts)
 ```ts
-import { CancelledFailure, CancellationScope, sleep } from '@temporalio/workflow';
+import { CancellationScope, CancelledFailure, sleep } from '@temporalio/workflow';
 
 export async function cancelTimerAltImpl(): Promise<void> {
   try {
@@ -112,7 +123,7 @@ The following code shows how to handle Workflow cancellation by an external clie
 <!--SNIPSTART typescript-handle-external-workflow-cancellation-while-activity-running-->
 [packages/test/src/workflows/handle-external-workflow-cancellation-while-activity-running.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/handle-external-workflow-cancellation-while-activity-running.ts)
 ```ts
-import { CancellationScope, proxyActivities, isCancellation } from '@temporalio/workflow';
+import { CancellationScope, isCancellation, proxyActivities } from '@temporalio/workflow';
 import type * as activities from '../activities';
 
 const { httpPostJSON, cleanup } = proxyActivities<typeof activities>({
@@ -153,8 +164,8 @@ export async function nonCancellable(url: string): Promise<any> {
 
 ### withTimeout example
 
-A common operation is to cancel one or more Activities if a deadline elapses.
-`withTimeout` creates a `CancellationScope` that is automatically cancelled after a timeout.
+A common operation is to cancel one or more Activities if a deadline elapses. `withTimeout` creates a
+`CancellationScope` that is automatically cancelled after a timeout.
 
 <!--SNIPSTART typescript-multiple-activities-single-timeout-workflow-->
 [packages/test/src/workflows/multiple-activities-single-timeout.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/multiple-activities-single-timeout.ts)
@@ -208,8 +219,9 @@ export async function resumeAfterCancellation(url: string): Promise<any> {
 
 ### Cancellation scopes and callbacks
 
-Callbacks are not particularly useful in Workflows because all meaningful asynchronous operations return promises.
-In the rare case that code uses callbacks and needs to handle cancellation, a callback can consume the `CancellationScope.cancelRequested` promise.
+Callbacks are not particularly useful in Workflows because all meaningful asynchronous operations return promises. In
+the rare case that code uses callbacks and needs to handle cancellation, a callback can consume the
+`CancellationScope.cancelRequested` promise.
 
 <!--SNIPSTART typescript-cancellation-scopes-with-callbacks-->
 [packages/test/src/workflows/cancellation-scopes-with-callbacks.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/cancellation-scopes-with-callbacks.ts)
@@ -236,7 +248,7 @@ You can achieve complex flows by nesting cancellation scopes.
 <!--SNIPSTART typescript-nested-cancellation-scopes-->
 [packages/test/src/workflows/nested-cancellation.ts](https://github.com/temporalio/sdk-typescript/blob/main/packages/test/src/workflows/nested-cancellation.ts)
 ```ts
-import { CancellationScope, proxyActivities, isCancellation } from '@temporalio/workflow';
+import { CancellationScope, isCancellation, proxyActivities } from '@temporalio/workflow';
 
 import type * as activities from '../activities';
 
@@ -262,8 +274,8 @@ export async function nestedCancellation(url: string): Promise<void> {
 
 ### Sharing promises between scopes
 
-Operations like Timers and Activities are cancelled by the cancellation scope they were created in.
-Promises returned by these operations can be awaited in different scopes.
+Operations like Timers and Activities are cancelled by the cancellation scope they were created in. Promises returned by
+these operations can be awaited in different scopes.
 
 <!--SNIPSTART typescript-shared-promise-scopes-->
 [activities-cancellation-heartbeating/src/cancellation-scopes.ts](https://github.com/temporalio/samples-typescript/blob/main/activities-cancellation-heartbeating/src/cancellation-scopes.ts)
@@ -304,17 +316,20 @@ export async function shieldAwaitedInRootScope(): Promise<any> {
 
 ## Cancel an Activity from a Workflow {#cancel-an-activity}
 
-Canceling an Activity from within a Workflow requires that the Activity Execution sends Heartbeats and sets a Heartbeat Timeout.
-If the Heartbeat is not invoked, the Activity cannot receive a cancellation request.
-When any non-immediate Activity is executed, the Activity Execution should send Heartbeats and set a [Heartbeat Timeout](/encyclopedia/detecting-activity-failures#heartbeat-timeout) to ensure that the server knows it is still working.
+Canceling an Activity from within a Workflow requires that the Activity Execution sends Heartbeats and sets a Heartbeat
+Timeout. If the Heartbeat is not invoked, the Activity cannot receive a cancellation request. When any non-immediate
+Activity is executed, the Activity Execution should send Heartbeats and set a
+[Heartbeat Timeout](/encyclopedia/detecting-activity-failures#heartbeat-timeout) to ensure that the server knows it is
+still working.
 
-When an Activity is canceled, an error is raised in the Activity at the next available opportunity.
-If cleanup logic needs to be performed, it can be done in a `finally` clause or inside a caught cancel error.
-However, for the Activity to appear canceled the exception needs to be re-thrown.
+When an Activity is canceled, an error is raised in the Activity at the next available opportunity. If cleanup logic
+needs to be performed, it can be done in a `finally` clause or inside a caught cancel error. However, for the Activity
+to appear canceled the exception needs to be re-thrown.
 
 :::note
 
-Unlike regular Activities, [Local Activities](/local-activity) can be canceled if they don't send Heartbeats.
-Local Activities are handled locally, and all the information needed to handle the cancellation logic is available in the same Worker process.
+Unlike regular Activities, [Local Activities](/local-activity) can be canceled if they don't send Heartbeats. Local
+Activities are handled locally, and all the information needed to handle the cancellation logic is available in the same
+Worker process.
 
 :::

docs/encyclopedia/activities/activities.mdx

@@ -21,9 +21,9 @@ This guide provides a comprehensive overview of Temporal Activities including
 [Activity Definition](/activity-definition), [Activity Type](/activity-definition#activity-type),
 [Activity Execution](/activity-execution), and [Local Activity](/local-activity).
 
-An Activity is a normal function or method that executes a single, well-defined action, such as calling another service,
-transcoding a media file, or sending an email message. An Activity can either be short or long-running. Activity code
-can be non-deterministic. We recommend that it be [idempotent](/activity-definition#idempotency).
+An Activity is a normal function or method that executes a single, well-defined action (either short or long running),
+such as calling another service, transcoding a media file, or sending an email message. Activity code can be
+non-deterministic. We recommend that it be [idempotent](/activity-definition#idempotency).
 
 Workflow code orchestrates the execution of Activities, persisting the results. If an Activity Function Execution fails,
 any future execution starts from initial state (except