@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.0

package/pipeline/skills/shared/external/swift-codable/SKILL.md

@@ -61,36 +61,11 @@ be computed some other way.
 Write `init(from:)` and `encode(to:)` when a value needs converting on the
 way in or out.
 
-```swift
-struct Shipment: Codable {
-    let reference: String
-    let dispatchedAt: Date
-    let labels: [String]
-
-    enum CodingKeys: String, CodingKey {
-        case reference, dispatchedAt = "dispatched_epoch", labels
-    }
-
-    init(from decoder: any Decoder) throws {
-        let fields = try decoder.container(keyedBy: CodingKeys.self)
-        reference = try fields.decode(String.self, forKey: .reference)
-        let seconds = try fields.decode(Double.self, forKey: .dispatchedAt)
-        dispatchedAt = Date(timeIntervalSince1970: seconds)
-        labels = try fields.decodeIfPresent([String].self, forKey: .labels) ?? []
-    }
-
-    func encode(to encoder: any Encoder) throws {
-        var fields = encoder.container(keyedBy: CodingKeys.self)
-        try fields.encode(reference, forKey: .reference)
-        try fields.encode(dispatchedAt.timeIntervalSince1970, forKey: .dispatchedAt)
-        try fields.encode(labels, forKey: .labels)
-    }
-}
-```
-
 Doing the conversion here, instead of patching values after decoding, keeps
 invalid instances from ever existing.
 
+Code for this section: [Codable recipes](references/codable-recipes.md).
+
 ## Nested and flattened containers
 
 JSON often nests what the app wants flat. `nestedContainer(keyedBy:forKey:)`
@@ -125,65 +100,21 @@ For a list whose elements differ by a `kind` field, model the element as an
 enum with associated values. Read the discriminator first, then the payload it
 selects.
 
-```swift
-enum FeedItem: Decodable {
-    case note(String)
-    case photo(URL)
-    case poll(options: [String])
-
-    enum Keys: String, CodingKey { case kind, text, url, options }
-
-    init(from decoder: any Decoder) throws {
-        let item = try decoder.container(keyedBy: Keys.self)
-        switch try item.decode(String.self, forKey: .kind) {
-        case "note":  self = .note(try item.decode(String.self, forKey: .text))
-        case "photo": self = .photo(try item.decode(URL.self, forKey: .url))
-        case "poll":  self = .poll(options: try item.decode([String].self, forKey: .options))
-        case let other:
-            throw DecodingError.dataCorruptedError(
-                forKey: .kind, in: item, debugDescription: "No FeedItem kind named \(other)")
-        }
-    }
-}
-
-let feed = try JSONDecoder().decode([FeedItem].self, from: payload)
-```
+Code for this section: [Codable recipes](references/codable-recipes.md).
 
 ## Date decoding strategies
 
-Set the strategy on the decoder to match what the server sends.
-
-```swift
-let reader = JSONDecoder()
-
-reader.dateDecodingStrategy = .iso8601               // "2025-11-02T08:15:00Z"
-reader.dateDecodingStrategy = .secondsSince1970      // 1762071300
-
-let dayFormat = DateFormatter()
-dayFormat.dateFormat = "dd.MM.yyyy"
-dayFormat.locale = Locale(identifier: "en_US_POSIX")
-dayFormat.timeZone = TimeZone(secondsFromGMT: 0)
-reader.dateDecodingStrategy = .formatted(dayFormat)  // "02.11.2025"
-```
-
-When one field arrives in more than one shape, decode it by hand:
+Set the strategy on the decoder to match what the server sends: `.iso8601`,
+`.secondsSince1970`, or `.formatted` with an `en_US_POSIX`, UTC `DateFormatter`.
 
-```swift
-reader.dateDecodingStrategy = .custom { decoder in
-    let raw = try decoder.singleValueContainer()
-    let text = try raw.decode(String.self)
-    let withFraction = ISO8601DateFormatter()
-    withFraction.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-    if let date = withFraction.date(from: text) ?? ISO8601DateFormatter().date(from: text) {
-        return date
-    }
-    throw DecodingError.dataCorruptedError(in: raw, debugDescription: "Unreadable date: \(text)")
-}
-```
+When one field arrives in more than one shape, decode it by hand with a
+`.custom` strategy.
 
 Give the encoder the matching strategy, for example
 `writer.dateEncodingStrategy = .iso8601`, so values round-trip.
 
+Code for this section: [Codable recipes](references/codable-recipes.md).
+
 ## Data and key strategies
 
 ```swift
@@ -211,37 +142,15 @@ ordinary key.
 
 By default a single bad element throws, and the whole array is lost. When a
 feed is known to be unreliable, wrap each element so a failure becomes `nil`
-and the container still moves on:
-
-```swift
-struct TolerantList<Element: Decodable>: Decodable {
-    let items: [Element]
-
-    private struct Slot: Decodable {
-        let value: Element?
-        init(from decoder: any Decoder) throws {
-            value = try? Element(from: decoder)
-        }
-    }
-
-    init(from decoder: any Decoder) throws {
-        var list = try decoder.unkeyedContainer()
-        var kept: [Element] = []
-        while !list.isAtEnd {
-            if let value = try list.decode(Slot.self).value {
-                kept.append(value)
-            }
-        }
-        items = kept
-    }
-}
-```
+and the container still moves on (the `Slot` wrapper in the reference).
 
 Decoding `Slot` always succeeds, so the unkeyed container always advances.
 A skip trick that decodes an empty placeholder struct only works when the bad
 element is a JSON object; a bad string or number would throw again and leave
 the loop stuck on the same index.
 
+Code for this section: [Codable recipes](references/codable-recipes.md).
+
 ## Single value containers
 
 A wrapper type that should appear in JSON as a bare value uses the single value
@@ -394,52 +303,8 @@ needs something SwiftData cannot store, hand it to the SwiftData skill.
 
 `@AppStorage` is for small preferences: `Bool`, numbers, `String`, `URL`,
 `Data`, or a `RawRepresentable` whose raw value is `Int` or `String`. A small
-Codable preference can ride on a JSON string raw value:
-
-```swift
-struct PlaybackPrefs: Codable {
-    var speed: Double = 1.0
-    var skipSilence = false
-
-    init() {}
-
-    enum CodingKeys: String, CodingKey { case speed, skipSilence }
-
-    init(from decoder: any Decoder) throws {
-        let fields = try decoder.container(keyedBy: CodingKeys.self)
-        speed = try fields.decodeIfPresent(Double.self, forKey: .speed) ?? 1.0
-        skipSilence = try fields.decodeIfPresent(Bool.self, forKey: .skipSilence) ?? false
-    }
-
-    func encode(to encoder: any Encoder) throws {
-        var fields = encoder.container(keyedBy: CodingKeys.self)
-        try fields.encode(speed, forKey: .speed)
-        try fields.encode(skipSilence, forKey: .skipSilence)
-    }
-}
-
-extension PlaybackPrefs: RawRepresentable {
-    init?(rawValue: String) {
-        guard let bytes = rawValue.data(using: .utf8),
-              let value = try? JSONDecoder().decode(PlaybackPrefs.self, from: bytes) else { return nil }
-        self = value
-    }
-
-    var rawValue: String {
-        guard let bytes = try? JSONEncoder().encode(self),
-              let text = String(data: bytes, encoding: .utf8) else { return "{}" }
-        return text
-    }
-}
-
-struct PlaybackSettingsView: View {
-    @AppStorage("playbackPrefs") private var prefs = PlaybackPrefs()
-
-    var body: some View {
-        Toggle("Skip silence", isOn: $prefs.skipSilence)
-    }
-}
-```
+Codable preference can ride on a JSON string raw value (full type in the
+reference).
 
 Two details make this bridge safe:
 
@@ -451,6 +316,8 @@ Two details make this bridge safe:
   values stored by an older version with fewer keys still decode. Synthesized
   decoding would ignore the property defaults and fail on `{}`.
 
+Code for this section: [Codable recipes](references/codable-recipes.md).
+
 ## Common mistakes
 
 1. **`decode` for a key that may be absent.** It throws `keyNotFound`. Use
@@ -482,6 +349,7 @@ Two details make this bridge safe:
 
 ## References
 
+- [Codable recipes](references/codable-recipes.md): open when writing a custom `init(from:)`, decoding mixed-type arrays, choosing a date strategy, skipping bad array elements or persisting Codable values in UserDefaults.
 - [Codable](https://developer.apple.com/documentation/swift/codable)
 - [JSONDecoder](https://developer.apple.com/documentation/foundation/jsondecoder)
 - [JSONEncoder](https://developer.apple.com/documentation/foundation/jsonencoder)

package/pipeline/skills/shared/external/swift-codable/references/codable-recipes.md

@@ -0,0 +1,207 @@
+# Codable recipes
+
+<!-- toc -->
+- [Custom decoding and encoding](#custom-decoding-and-encoding)
+- [Heterogeneous arrays](#heterogeneous-arrays)
+- [Date decoding strategies](#date-decoding-strategies)
+- [Lossy array decoding](#lossy-array-decoding)
+- [Codable with UserDefaults](#codable-with-userdefaults)
+<!-- /toc -->
+
+Full code for custom decoding, heterogeneous arrays, date strategies, lossy arrays and storing Codable values in UserDefaults. SKILL.md keeps the rules and when to use each technique.
+
+## Custom decoding and encoding
+
+Write `init(from:)` and `encode(to:)` when a value needs converting on the
+way in or out.
+
+```swift
+struct Shipment: Codable {
+    let reference: String
+    let dispatchedAt: Date
+    let labels: [String]
+
+    enum CodingKeys: String, CodingKey {
+        case reference, dispatchedAt = "dispatched_epoch", labels
+    }
+
+    init(from decoder: any Decoder) throws {
+        let fields = try decoder.container(keyedBy: CodingKeys.self)
+        reference = try fields.decode(String.self, forKey: .reference)
+        let seconds = try fields.decode(Double.self, forKey: .dispatchedAt)
+        dispatchedAt = Date(timeIntervalSince1970: seconds)
+        labels = try fields.decodeIfPresent([String].self, forKey: .labels) ?? []
+    }
+
+    func encode(to encoder: any Encoder) throws {
+        var fields = encoder.container(keyedBy: CodingKeys.self)
+        try fields.encode(reference, forKey: .reference)
+        try fields.encode(dispatchedAt.timeIntervalSince1970, forKey: .dispatchedAt)
+        try fields.encode(labels, forKey: .labels)
+    }
+}
+```
+
+Doing the conversion here, instead of patching values after decoding, keeps
+invalid instances from ever existing.
+
+## Heterogeneous arrays
+
+For a list whose elements differ by a `kind` field, model the element as an
+enum with associated values. Read the discriminator first, then the payload it
+selects.
+
+```swift
+enum FeedItem: Decodable {
+    case note(String)
+    case photo(URL)
+    case poll(options: [String])
+
+    enum Keys: String, CodingKey { case kind, text, url, options }
+
+    init(from decoder: any Decoder) throws {
+        let item = try decoder.container(keyedBy: Keys.self)
+        switch try item.decode(String.self, forKey: .kind) {
+        case "note":  self = .note(try item.decode(String.self, forKey: .text))
+        case "photo": self = .photo(try item.decode(URL.self, forKey: .url))
+        case "poll":  self = .poll(options: try item.decode([String].self, forKey: .options))
+        case let other:
+            throw DecodingError.dataCorruptedError(
+                forKey: .kind, in: item, debugDescription: "No FeedItem kind named \(other)")
+        }
+    }
+}
+
+let feed = try JSONDecoder().decode([FeedItem].self, from: payload)
+```
+
+## Date decoding strategies
+
+Set the strategy on the decoder to match what the server sends.
+
+```swift
+let reader = JSONDecoder()
+
+reader.dateDecodingStrategy = .iso8601               // "2025-11-02T08:15:00Z"
+reader.dateDecodingStrategy = .secondsSince1970      // 1762071300
+
+let dayFormat = DateFormatter()
+dayFormat.dateFormat = "dd.MM.yyyy"
+dayFormat.locale = Locale(identifier: "en_US_POSIX")
+dayFormat.timeZone = TimeZone(secondsFromGMT: 0)
+reader.dateDecodingStrategy = .formatted(dayFormat)  // "02.11.2025"
+```
+
+When one field arrives in more than one shape, decode it by hand:
+
+```swift
+reader.dateDecodingStrategy = .custom { decoder in
+    let raw = try decoder.singleValueContainer()
+    let text = try raw.decode(String.self)
+    let withFraction = ISO8601DateFormatter()
+    withFraction.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    if let date = withFraction.date(from: text) ?? ISO8601DateFormatter().date(from: text) {
+        return date
+    }
+    throw DecodingError.dataCorruptedError(in: raw, debugDescription: "Unreadable date: \(text)")
+}
+```
+
+Give the encoder the matching strategy, for example
+`writer.dateEncodingStrategy = .iso8601`, so values round-trip.
+
+## Lossy array decoding
+
+By default a single bad element throws, and the whole array is lost. When a
+feed is known to be unreliable, wrap each element so a failure becomes `nil`
+and the container still moves on:
+
+```swift
+struct TolerantList<Element: Decodable>: Decodable {
+    let items: [Element]
+
+    private struct Slot: Decodable {
+        let value: Element?
+        init(from decoder: any Decoder) throws {
+            value = try? Element(from: decoder)
+        }
+    }
+
+    init(from decoder: any Decoder) throws {
+        var list = try decoder.unkeyedContainer()
+        var kept: [Element] = []
+        while !list.isAtEnd {
+            if let value = try list.decode(Slot.self).value {
+                kept.append(value)
+            }
+        }
+        items = kept
+    }
+}
+```
+
+Decoding `Slot` always succeeds, so the unkeyed container always advances.
+A skip trick that decodes an empty placeholder struct only works when the bad
+element is a JSON object; a bad string or number would throw again and leave
+the loop stuck on the same index.
+
+## Codable with UserDefaults
+
+`@AppStorage` is for small preferences: `Bool`, numbers, `String`, `URL`,
+`Data`, or a `RawRepresentable` whose raw value is `Int` or `String`. A small
+Codable preference can ride on a JSON string raw value:
+
+```swift
+struct PlaybackPrefs: Codable {
+    var speed: Double = 1.0
+    var skipSilence = false
+
+    init() {}
+
+    enum CodingKeys: String, CodingKey { case speed, skipSilence }
+
+    init(from decoder: any Decoder) throws {
+        let fields = try decoder.container(keyedBy: CodingKeys.self)
+        speed = try fields.decodeIfPresent(Double.self, forKey: .speed) ?? 1.0
+        skipSilence = try fields.decodeIfPresent(Bool.self, forKey: .skipSilence) ?? false
+    }
+
+    func encode(to encoder: any Encoder) throws {
+        var fields = encoder.container(keyedBy: CodingKeys.self)
+        try fields.encode(speed, forKey: .speed)
+        try fields.encode(skipSilence, forKey: .skipSilence)
+    }
+}
+
+extension PlaybackPrefs: RawRepresentable {
+    init?(rawValue: String) {
+        guard let bytes = rawValue.data(using: .utf8),
+              let value = try? JSONDecoder().decode(PlaybackPrefs.self, from: bytes) else { return nil }
+        self = value
+    }
+
+    var rawValue: String {
+        guard let bytes = try? JSONEncoder().encode(self),
+              let text = String(data: bytes, encoding: .utf8) else { return "{}" }
+        return text
+    }
+}
+
+struct PlaybackSettingsView: View {
+    @AppStorage("playbackPrefs") private var prefs = PlaybackPrefs()
+
+    var body: some View {
+        Toggle("Skip silence", isOn: $prefs.skipSilence)
+    }
+}
+```
+
+Two details make this bridge safe:
+
+- `encode(to:)` and `init(from:)` are written out. When a type is both
+  `RawRepresentable` and Codable, the standard library's `RawRepresentable`
+  defaults would otherwise encode `rawValue`, which encodes `self`, which
+  recurses until the stack overflows.
+- Decoding uses `decodeIfPresent` with defaults, so the `"{}"` fallback and
+  values stored by an older version with fewer keys still decode. Synthesized
+  decoding would ignore the property defaults and fail on `{}`.

package/pipeline/skills/shared/external/swift-concurrency/SKILL.md

@@ -82,22 +82,7 @@ SwiftPM `swiftSettings` array, or the Xcode build setting. Use it for app
 targets, scripts and other executables where most code serves the UI. Leave
 library targets without it so they stay usable from any isolation.
 
-```swift
-// Target built with Default Actor Isolation = MainActor: no annotations needed.
-final class PlaybackQueue {
-    static let current = PlaybackQueue()   // main-actor protected
-    var upcoming: [Episode] = []            // main-actor protected
-}
-
-final class EpisodeLibrary {
-    let renderer = WaveformRenderer()
-    var pinned: [Episode.ID] = []
-}
-
-extension EpisodeLibrary: Archivable {      // conformance is main-actor isolated too
-    func archive() -> Data { Data() }
-}
-```
+Code: [Approachable concurrency in Swift 6.2](references/code-examples.md#approachable-concurrency-in-swift-62).
 
 **Async functions stay where they are called (SE-0461).** With
 `NonisolatedNonsendingByDefault` on, a `nonisolated` async function runs on the
@@ -105,22 +90,7 @@ caller's actor instead of jumping to the global concurrent executor. That
 behavior is spelled `nonisolated(nonsending)`. Without the feature, Swift 6.0
 and 6.1 semantics still apply and the function leaves the caller's actor.
 
-```swift
-final class WaveformRenderer {
-    func render(_ audio: Data) async -> Waveform { Waveform(samples: []) }
-}
-
-@MainActor
-final class EpisodeDetailModel {
-    let renderer = WaveformRenderer()
-    var waveform: Waveform?
-
-    func open(_ url: URL) async throws {
-        let (audio, _) = try await URLSession.shared.data(from: url)
-        waveform = await renderer.render(audio)   // stays on the main actor: no race reported
-    }
-}
-```
+Code: [Approachable concurrency in Swift 6.2](references/code-examples.md#approachable-concurrency-in-swift-62).
 
 **`@concurrent` asks for the thread pool on purpose.** A `@concurrent` function
 always runs on the concurrent pool, which frees the calling actor. To move a
@@ -131,32 +101,11 @@ piece of work off the caller:
 3. Make the function `async` if it is not already.
 4. Put `await` at each call site.
 
-```swift
-nonisolated struct TranscriptBuilder {
-    @concurrent
-    func build(from audio: Data) async -> Transcript? { Transcript(lines: []) }
-}
-
-// On the main actor:
-transcripts[episode.id] = await builder.build(from: audio)
-```
+Code: [Approachable concurrency in Swift 6.2](references/code-examples.md#approachable-concurrency-in-swift-62).
 
-**Other 6.2 additions**, each covered in
-[concurrency-patterns.md](references/concurrency-patterns.md):
-
-- `Task.immediate` (SE-0472) runs synchronously on the current actor until its
-  first suspension instead of being enqueued; `Task.immediateDetached` adds
-  detached semantics. Use it where the enqueue delay is visible to the user,
-  for example `Task.immediate { await search.apply(query) }`.
-- `Observations { }` (SE-0475) turns reads of `@Observable` properties into an
-  `AsyncSequence` with transactional updates:
-  `for await elapsed in Observations({ player.elapsed }) { scrubber.move(to: elapsed) }`.
-- Isolated conformances let a main-actor type conform to a protocol whose
-  requirements it can only meet on the main actor. The compiler allows the
-  conformance only where that isolation holds.
-- SE-0473 adds `.epoch` to `ContinuousClock` and `SuspendingClock`, but the
-  iOS 26.4 SDK does not ship it yet ("value of type 'ContinuousClock' has no
-  member 'epoch'"); check your SDK before relying on it.
+**Other 6.2 additions** (`Task.immediate`, `Observations { }`, isolated conformances, clock `.epoch`):
+[swift-6-2-additions.md](references/swift-6-2-additions.md), in depth in
+[concurrency-patterns.md](references/concurrency-patterns.md).
 
 ## Isolation rules
 
@@ -199,20 +148,7 @@ transcripts[episode.id] = await builder.build(from: audio)
 | `Task.immediate { }` | Same as `Task`, starts at once | Latency-sensitive starts (OS 26 runtime) |
 | `Task.detached { }` | Nothing | Deliberately breaking inheritance; see the rule below |
 
-```swift
-async let profile = api.profile(for: userID)
-async let badges = api.badges(for: userID)
-let (loadedProfile, loadedBadges) = try await (profile, badges)
-
-let episodes = try await withThrowingTaskGroup(of: Episode.self) { group in
-    for id in episodeIDs {
-        group.addTask { try await api.episode(id) }
-    }
-    var collected: [Episode] = []
-    for try await episode in group { collected.append(episode) }
-    return collected
-}
-```
+Code: [Tasks and structured concurrency](references/code-examples.md#tasks-and-structured-concurrency).
 
 SE-0493 lets a `defer` body `await`, but the Swift 6.3.1 compiler in Xcode
 26.4 still rejects it with "'async' call cannot occur in a defer body". Until
@@ -247,25 +183,7 @@ Cancellation is a request the task must honor itself.
 An actor runs one piece of code at a time, but every `await` inside it lets
 other calls in. State read before an `await` may be stale after it.
 
-```swift
-actor TicketCounter {
-    private var sold = 0
-    private let audit: AuditLog
-
-    init(audit: AuditLog) { self.audit = audit }
-
-    func sellLosingUpdates() async {
-        let current = sold
-        await audit.record(current)
-        sold = current + 1          // another call may have run during the await
-    }
-
-    func sell() async {
-        sold += 1                   // read and write with no suspension between them
-        await audit.record(sold)
-    }
-}
-```
+Code: [Actor reentrancy](references/code-examples.md#actor-reentrancy).
 
 ## Streams and continuations
 
@@ -273,15 +191,7 @@ Bridge APIs that call back many times with `AsyncStream`, and single-shot
 callbacks with `withCheckedContinuation` or `withCheckedThrowingContinuation`.
 A continuation is resumed exactly once on every path.
 
-```swift
-func readings(from scale: BluetoothScale) -> AsyncStream<Measurement<UnitMass>> {
-    AsyncStream { continuation in
-        let subscription = scale.observe { continuation.yield($0) }
-        continuation.onTermination = { _ in subscription.cancel() }
-        scale.startStreaming()
-    }
-}
-```
+Code: [Streams and continuations](references/code-examples.md#streams-and-continuations).
 
 Delegate bridges, cancellation-aware continuations and the full GCD mapping are
 in [bridging-interop.md](references/bridging-interop.md).
@@ -381,3 +291,6 @@ second choices, each with a named reason.
   adoption order, Thread Sanitizer.
 - [async-algorithms.md](references/async-algorithms.md): the
   swift-async-algorithms package.
+- [swift-6-2-additions.md](references/swift-6-2-additions.md): `Task.immediate`,
+  `Observations { }`, isolated conformances and the clock `.epoch` status.
+- [Code examples](references/code-examples.md): open for the full code behind Approachable concurrency in Swift 6.2, Tasks and structured concurrency, Actor reentrancy, Streams and continuations.

package/pipeline/skills/shared/external/swift-concurrency/references/code-examples.md

@@ -0,0 +1,100 @@
+# Swift Concurrency Code Examples
+
+Full code samples for the SKILL.md sections that link here. The rules and the decision guidance stay in SKILL.md; each heading below matches the SKILL.md section the code belongs to.
+
+## Approachable concurrency in Swift 6.2
+
+```swift
+// Target built with Default Actor Isolation = MainActor: no annotations needed.
+final class PlaybackQueue {
+    static let current = PlaybackQueue()   // main-actor protected
+    var upcoming: [Episode] = []            // main-actor protected
+}
+
+final class EpisodeLibrary {
+    let renderer = WaveformRenderer()
+    var pinned: [Episode.ID] = []
+}
+
+extension EpisodeLibrary: Archivable {      // conformance is main-actor isolated too
+    func archive() -> Data { Data() }
+}
+```
+
+```swift
+final class WaveformRenderer {
+    func render(_ audio: Data) async -> Waveform { Waveform(samples: []) }
+}
+
+@MainActor
+final class EpisodeDetailModel {
+    let renderer = WaveformRenderer()
+    var waveform: Waveform?
+
+    func open(_ url: URL) async throws {
+        let (audio, _) = try await URLSession.shared.data(from: url)
+        waveform = await renderer.render(audio)   // stays on the main actor: no race reported
+    }
+}
+```
+
+```swift
+nonisolated struct TranscriptBuilder {
+    @concurrent
+    func build(from audio: Data) async -> Transcript? { Transcript(lines: []) }
+}
+
+// On the main actor:
+transcripts[episode.id] = await builder.build(from: audio)
+```
+
+## Tasks and structured concurrency
+
+```swift
+async let profile = api.profile(for: userID)
+async let badges = api.badges(for: userID)
+let (loadedProfile, loadedBadges) = try await (profile, badges)
+
+let episodes = try await withThrowingTaskGroup(of: Episode.self) { group in
+    for id in episodeIDs {
+        group.addTask { try await api.episode(id) }
+    }
+    var collected: [Episode] = []
+    for try await episode in group { collected.append(episode) }
+    return collected
+}
+```
+
+## Actor reentrancy
+
+```swift
+actor TicketCounter {
+    private var sold = 0
+    private let audit: AuditLog
+
+    init(audit: AuditLog) { self.audit = audit }
+
+    func sellLosingUpdates() async {
+        let current = sold
+        await audit.record(current)
+        sold = current + 1          // another call may have run during the await
+    }
+
+    func sell() async {
+        sold += 1                   // read and write with no suspension between them
+        await audit.record(sold)
+    }
+}
+```
+
+## Streams and continuations
+
+```swift
+func readings(from scale: BluetoothScale) -> AsyncStream<Measurement<UnitMass>> {
+    AsyncStream { continuation in
+        let subscription = scale.observe { continuation.yield($0) }
+        continuation.onTermination = { _ in subscription.cancel() }
+        scale.startStreaming()
+    }
+}
+```