Craig Macomber (Microsoft)

Introduce Unified ServiceClient API for Fluid Client (#27693) ## Description This add a simple API as a cleaner alternative to fluid-static and aquaduct. The implementation details are well encapsulated, making this a viable alternative to the `fluid-static` public API and a viable successor to the existing much larger legacy API surface we do not want to stabilize. This addresses several issues with our existing APIs: 1. non-legacy (fluid-static declarative model) API: 1. No stable way to use local service for testing (Internally or for customers). Forces tests to use alternative patterns (like test-utils, mocks etc. or a separate azure local service process). 2. No way to avoid bundling in SharedDirectory. 3. Defining and using DataStores is not well supported, especially for the root. 4. Dependency layering is such that its disallowed for DDS packages to use the public API surfaces to do collab tests. 5. No abstraction for Services / ServiceClient makes logic portable over services harder to write. 6. Doesn't support lazy loading DDS and DataStore code (at least not clearly/cleanly). 7. No migration path from legacy APIs to this 3. legacy (encapsulated model, including aquaduct): 1. Leak way too many details with too many non-sealed interfaces presenting tons of theoretical extension points we don't want to stabilize. 2. Encourages use of DataObject and its subclassing based extension approach which is limiting (Like how it makes switching to root trees) hard, and makes changing the implementation without introducing breaking changes very difficult. Because this new "unified" API offers value for our own internal testing (for example in tree), it is useful, even as alpha (or internal). Exposing this new API as alpha should be low risk, as it makes no long-term commitments. Since we have first party in-repo use cases, it should be practical to refine and iterate on this API with use in test and examples before we consider promoting it to beta. Requirements for this new API: 1. Testing: 2. Can easily be used for tests including collab and reopening documents. 3. Can be used by DDS (like shared-tree) tests replacing the need for many of our mocks and test utils 4. Can be used by customers (apps and libraries requiring stable APIs when promoted past alpha). When adopted, customers should not have need of any of our legacy test-utils and mocks (so we can migrate our legacy apps off of our test utils and eventually make them internal only). 5. Will be possible to stabilize to public (or at least beta) without depending on or stabilizing legacy APIs. 6. Is easy to use for tests, including collab. 7. Is easy to use for real production apps (should work the same as with tests). 8. Provides a clear and practical incremental migration path from both existing APIs: there can be gaps we need to close for some use-cases but those gaps need to be practical to close.

Factor out tree identifier compression and healing utils (#27367) ## Description Factor out tree identifier compression and healing utils. Remove the originator id (which is incorrect) that is passed down into the field batch codec, factoring the encode and decode codecs into different types which only take in exactly what they should have. This intentionally changes `IIdCompressor` from `@public` to `@public @sealed`. While in some ways this is a breaking change, custom implementations of `IIdCompressor` didn't actually work due to us already having code which assumes they are our implementation and down casts them. Therefor adding `@sealed` is more of a bug fix than a break.

feat(tree): add alpha Component utilities for open-polymorphic schema (#27628) ## Description Promotes the `Component` composition namespace out of the `openPolymorphism.integration.ts` test file and into `@fluidframework/tree` as a new `@alpha` API (also re-exported from `fluid-framework`). This pattern was previously validated only by the open-polymorphism examples; it's now a supported (alpha) part of the package because an app depends on it. `Component` provides utilities for composing independently authored application "components" that contribute to a shared configuration — useful for "open polymorphism" schema patterns where the set of allowed types for a field or collection can be extended by separate libraries. Each component is a `Component.Factory` that receives a lazy reference to the composed configuration and returns the content it contributes; `Component.composeComponents` combines them into a `Component.ComposedComponents`. Changes: - New `packages/dds/tree/src/simple-tree/api/componentApi.ts` with the `@alpha`-tagged, fully documented `Component` namespace, exporting only what's needed (`Factory`, `LazyArray`, `Configurable`, `composeComponents`, `ComposedComponents`); the `Config` implementation class stays internal. - Exported from `@fluidframework/tree` and (via the alpha entrypoint) `fluid-framework`; API reports updated. - The integration test now imports `Component` instead of defining it locally. - New focused unit tests in `componentApi.spec.ts` supplementing the existing example/integration tests. - Fixed a latent caching bug in `getConfigured` (it previously ran `configure` on every call; now cached via `getOrCreate`). - Changeset added.

fix(tree): Better asserts, and fix latent optimized forest array corruption bug (#27920) ## Description Improves validation and diagnostics for the optimized SharedTree forest. Internal attach, detach, create, and destroy operations are now validated before mutating forest state, preventing a failed operation from partially modifying the forest or consuming detached content. Additional assertions fail closer to the source of inconsistent operations, making failures such as later out-of-bounds chunk indexes easier to triage. This PR also corrects chunk indexing when a shared multi-node `SequenceChunk` is normalized for editing. The previous implementation could clone the selected child into the wrong slot and replace a sibling. This issue is currently unreachable through `ForestTypeOptimized`: its current chunk policy does not create sequence chunks, decoded fields are deaggregated, and delta builds split sequence content into individual node cursors. The fix and targeted tests preserve correctness if sequence chunks are used by this forest in the future or through internal/custom chunk configurations. Other changes ensure replaced chunk references are released correctly (improving our ability to edit in place) and add focused coverage for chunk lookup, copy-on-write normalization, operation atomicity, reference ownership, and field splitting.

Include final retain in tree deltas (#27809) ## Description Previously our array node deltas were not required to include the final retain. This is now always included. Additionally handling of the extra new line required to make quill more robust, fixing a bug where remote collaborators could end up with extra new lines.

If editing a forest fails, mark it as broken (#27955) ## Description If editing a forest fails, mark it as broken. This helps ensure that failed edits can't result in inconsistent forest states which get persisted spreading the corruption. This is done at two layers for improved robustness: the forest will make itself broken if its visitor crashes doing the updates. Addationally I have added higher level logic which will mark a forest as broken if we fail to load it, or fail to apply a change (from op or local) to it. This should have no impact in cases where no errors which should be fatal occur. This could prevent corruption from making it into an op or summary if we have a bug (in addition to the one causing the corruption) which tries to continue using the forest after an edit failed to apply, as it would make the later attempt to read the invalid forest throw indicating that it's broken by a previous fatal error.

Prefer `fail(` over `assert(false` (#27974) ## Description Prefer `fail(` over `assert(false`

refactor(tree): split encode/decode contexts for change and field codecs (#27758) ## Description Part of a set of changes for giving SharedTree's change codecs distinct encode-side and decode-side context types. Pure type-level refactor — **no runtime behavior change** — scoped to the change/field codecs. ### What changed 1. **Distinct decode contexts.** Add `ChangeDecodingContext` and `FieldChangeDecodingContext`, and thread `TDecodeContext` through the change/field codec family declarations (`ChangeFamily.codecs`, `ChangeFamilyCodec`, `FieldChangeHandler.codecsFactory`, the sequence/optional/generic field families, modular change, and shared-tree-change families). The codec infrastructure already supported a separate `TDecodeContext` defaulting to `TEncodeContext`, so this is mostly plumbing. 2. **Drop `schema` from `ChangeDecodingContext`** (`Omit<ChangeEncodingContext, "schema">`): it's only used for schema-aware compression on encode. 3. **Split `FieldChangeEncodingContext`/`FieldChangeDecodingContext`** into `encodeNode`-only and `decodeNode`-only interfaces, removing the `fail(...)` stubs `modularChangeCodecV1` previously used to guard against misuse. `ChangeEncodingContext` keeps `healing`/`originatorId` for now because the EditManager/Message codecs still use one context type for both directions; splitting those (and dropping the decode-only fields) is a follow-up. ### Tests - Round-trip contexts typed as `FieldChangeEncodingContext & FieldChangeDecodingContext`; encode-only snapshot contexts drop the unused `decodeNode`. - `makeEncodingTestSuite`/`registerValidationHook` generalized to accept split encode/decode contexts (backward-compatible via `TDecodeContext = TEncodeContext`).

Add simpler way to use Component (#27664) ## Description Add overload and default parameters to easy simple case use of Component API

Tweak support for 3.x in OldestSupportedClientVersion (#28022) ## Description Tweak how we support version 3, removing the complications that we likely shouldn't have stabilized for 1 and 2 from the new 3 support before we stabilize.