Merge branch 'main' into test/remove-handle-bind-fn

Author: markfields

.changeset/green-poets-run.md

@@ -0,0 +1,8 @@
+---
+"@fluidframework/presence": minor
+"__section": feature
+---
+
+Presence: runtime schema validation
+
+This is a placeholder changeset that will be updated in a future change.

.changeset/seven-toes-smell.md

@@ -0,0 +1,62 @@
+---
+"@fluidframework/tree": minor
+"fluid-framework": minor
+"__section": tree
+---
+Add TreeAlpha.child and TreeAlpha.children APIs for generic tree traversal
+
+#### TreeAlpha.child
+
+Access a child node or value of a `TreeNode` by its property key.
+
+```typescript
+class MyObject extends schemaFactory.object("MyObject", {
+	foo: schemaFactory.string;
+	bar: schemaFactory.optional(schemaFactory.string);
+}) {}
+
+const myObject = new MyObject({
+	foo: "Hello world!"
+});
+
+const foo = TreeAlpha.child(myObject, "foo"); // "Hello world!"
+const bar = TreeAlpha.child(myObject, "bar"); // undefined
+const baz = TreeAlpha.child(myObject, "baz"); // undefined
+```
+
+```typescript
+class MyArray extends schemaFactory.array("MyArray", schemaFactory.string) {}
+
+const myArray = new MyArray("Hello", "World");
+
+const child0 = TreeAlpha.child(myArray, 0); // "Hello"
+const child1 = TreeAlpha.child(myArray, 1); // "World
+const child2 = TreeAlpha.child(myArray, 2); // undefined
+```
+
+#### TreeAlpha.children
+
+Get all child nodes / values of a `TreeNode`, keyed by their property keys.
+
+```typescript
+class MyObject extends schemaFactory.object("MyObject", {
+	foo: schemaFactory.string;
+	bar: schemaFactory.optional(schemaFactory.string);
+	baz: schemaFactory.optional(schemaFactory.number);
+}) {}
+
+const myObject = new MyObject({
+	foo: "Hello world!",
+	baz: 42,
+});
+
+const children = TreeAlpha.children(myObject); // [["foo", "Hello world!"], ["baz", 42]]
+```
+
+```typescript
+class MyArray extends schemaFactory.array("MyArray", schemaFactory.string) {}
+
+const myArray = new MyArray("Hello", "World");
+
+const children = TreeAlpha.children(myObject); // [[0, "Hello"], [1, "World"]]
+```

.changeset/spotty-bottles-rest.md

@@ -0,0 +1,109 @@
+---
+"fluid-framework": minor
+"@fluidframework/tree": minor
+"__section": feature
+---
+Persisted metadata for Shared Tree schemas (Alpha)
+
+The persisted metadata feature for Shared Tree allows an application author to write document-persisted metadata along with the schema. This feature is supported for both node and field schemas.
+
+#### Using the persisted metadata feature
+
+As of now, persisted metadata support is available via the SchemaFactoryAlpha API:
+
+```ts
+// Construct a schema factory with alpha APIs
+const schemaFactory = new SchemaFactoryAlpha("com.example");
+```
+
+Persisted metadata can take the shape of any JSON-serializable object, e.g.:
+
+```ts
+const persistedMetadata = { a: 2 };
+```
+
+#### Feature flag
+
+To enable persisted metadata, use `configuredSharedTree` to specify the format version. The tree that is returned can be substituted in place of the default `SharedTree` object exported by the Fluid Framework. For example:
+
+```ts
+const tree = configuredSharedTree({
+    formatVersion: SharedTreeFormatVersion.v5,
+}).create(runtime);
+
+export const MyContainerSchema = {
+    initialObjects: {
+        appData: tree,
+    },
+} satisfies ContainerSchema;
+```
+
+#### Examples
+
+##### Field schemas with persisted metadata
+
+```ts
+// Construct a schema factory with alpha APIs
+const schemaFactory = new SchemaFactoryAlpha("com.example");
+
+// Define metadata. This can take the shape of any JSON-serializable object.
+const persistedMetadata = { "a": 2 };
+
+// Foo is an object type with metadata
+class Foo extends schemaFactory.objectAlpha("Foo", {
+    // Metadata for a required number field
+    bar: schemaFactory.required(schemaFactory.number, { persistedMetadata }),
+
+    // Metadata for an optional string field   
+    baz: schemaFactory.optional(schemaFactory.string, { persistedMetadata }),
+// Metadata for the object type Foo       
+}, { persistedMetadata }) {}
+```
+
+##### Recursive field schemas
+
+```ts
+// Construct a schema factory with alpha APIs
+const schemaFactory = new SchemaFactoryAlpha("com.example");
+
+// Define metadata. This can take the shape of any JSON-serializable object.
+const persistedMetadata = { "a": 2 };
+
+// Recursive object schema with persisted metadata
+class RecursiveObject extends schemaFactory.objectRecursive("RecursiveObject", {
+    x: [() => RecursiveObject, schemaFactory.number],
+}, { persistedMetadata }) {}
+
+// Recursive field schema with metadata
+const recursiveField = schemaFactory.optionalRecursive(
+    [() => RecursiveObject, schemaFactory.number],
+    { persistedMetadata });
+```
+
+##### Recursive object schemas
+
+```ts
+// Construct a schema factory with alpha APIs
+const schemaFactory = new SchemaFactoryAlpha("com.example");
+
+// Define metadata. This can take the shape of any JSON-serializable object.
+const persistedMetadata = { "a": 2 };
+
+// Recursive array schema
+class Foos extends schemaFactory.arrayRecursive(
+    "FooList",
+    [() => Foo],
+    { persistedMetadata }) {}
+
+// Recursive object schema
+class Foo extends schemaFactory.objectRecursive(
+    "Foo",
+    { fooList: Foos },
+    { persistedMetadata }) {}
+
+// Recursive map schema
+class FooMap extends schemaFactory.mapRecursive(
+    "FooMap",
+    [() => Foo],
+    { persistedMetadata }) {}
+```

.changeset/weak-bottles-count.md

@@ -0,0 +1,9 @@
+---
+"fluid-framework": minor
+"@fluidframework/tree": minor
+"__section": tree
+---
+Improved Schema Validation
+
+When constructing a [`TreeViewConfiguration`](https://fluidframework.com/docs/api/fluid-framework/treeviewconfiguration-class), the same schema listed more than once in a given [`AllowedTypes`](https://fluidframework.com/docs/api/fluid-framework/allowedtypes-typealias) is now an error even when [`preventAmbiguity`](https://fluidframework.com/docs/api/fluid-framework/treeviewconfiguration-class#preventambiguity-property) is false.
+Previously a bug resulted in this only being rejected when `preventAmbiguity` was true.

.changeset/whole-days-argue.md

@@ -63,7 +63,9 @@ jobs:
         run: echo "TAG_NAME=${GITHUB_REF}" >> $GITHUB_ENV
       - name: Set tag name from manual input
         if: github.event_name == 'workflow_dispatch'
-        run: echo "TAG_NAME=refs/tags/${{ github.event.inputs.tag }}" >> $GITHUB_ENV
+        env:
+          TAG: ${{ github.event.inputs.tag }}
+        run: echo "TAG_NAME=refs/tags/$TAG" >> $GITHUB_ENV
 
       - name: Get release metadata JSON
         run: |
@@ -86,12 +88,20 @@ jobs:
 
       - name: Check out tag from push
         if: github.event_name == 'push'
-        run: |
-          git checkout ${{ github.ref }}
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # ratchet:actions/checkout@v3
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0 # all history
+          persist-credentials: false
       - name: Check out tag from manual input
         if: github.event_name == 'workflow_dispatch'
-        run: |
-          git checkout refs/tags/${{ github.event.inputs.tag }}
+        env:
+          TAG: ${{ github.event.inputs.tag }}
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # ratchet:actions/checkout@v3
+        with:
+          ref: refs/tags/$TAG
+          fetch-depth: 0 # all history
+          persist-credentials: false
 
       # Generate release reports
       - name: Create release reports (manifests)

.github/workflows/push-tag-create-release.yml

@@ -71,9 +71,11 @@ jobs:
 
       ### These steps run on workflow_dispatch event only ###
       - name: "workflow_dispatch: Load PR number"
+        env:
+          PR: ${{ github.event.inputs.pr }}
         id: workflow_dispatch_load_pr
         if: github.event_name == 'workflow_dispatch'
-        run: echo "pr_num=${{ github.event.inputs.pr }}" >> $GITHUB_OUTPUT
+        run: echo "pr_num=$PR" >> $GITHUB_OUTPUT
 
       - name: "workflow_dispatch: Load is_release_branch"
         id: workflow_dispatch_is_release_branch

.github/workflows/release-approval.yml

@@ -47,6 +47,13 @@ export interface ILayerCompatDetails extends Partial<IProvideLayerCompatDetails>
 	/**
 	 * The generation of the layer. The other layer at the layer boundary uses this to check if this satisfies
 	 * the minimum generation it requires to be compatible.
+	 *
+	 * @remarks Generation is updated on a regular cadence, say, monthly. This will allow us to determine how
+	 * far apart two layers are in terms of time and whether they are compatible.
+	 * For example, say generation is updated every month and the compatibility window between layer1 and layer2 is
+	 * 6 months. Now, if layer1 is at generation 1 and layer2 is at generation 5, then they are 4 months apart and are
+	 * compatible. But if layer1 is at generation 1 and layer2 is at generation 8, then they are 7 months apart and
+	 * are not compatible.
 	 */
 	readonly generation: number;
 	/**

packages/common/client-utils/src/layerCompat.ts

@@ -4,11 +4,6 @@
 
 ```ts
 
-// @alpha @legacy (undocumented)
-export type FullyReadonly<T> = {
-    readonly [P in keyof T]: FullyReadonly<T[P]>;
-};
-
 // @alpha @legacy (undocumented)
 export interface IDeleteOperation {
     // (undocumented)
@@ -54,18 +49,24 @@ export interface ISharedArray<T extends SerializableTypeForSharedArray> extends
     // (undocumented)
     delete(index: number): void;
     // (undocumented)
-    get(): FullyReadonly<T[]>;
+    get(): readonly T[];
     // (undocumented)
     insert<TWrite>(index: number, value: Serializable<TWrite> & T): void;
     // (undocumented)
+    insertBulkAfter<TWrite>(ref: T | undefined, values: (Serializable<TWrite> & T)[]): void;
+    // (undocumented)
     move(oldIndex: number, newIndex: number): void;
+    // (undocumented)
+    toggle(entryId: string): void;
+    // (undocumented)
+    toggleMove(oldEntryId: string, newEntryId: string): void;
 }
 
 // @alpha @legacy
 export interface ISharedArrayEvents extends ISharedObjectEvents {
-    // (undocumented)
+    // @eventProperty (undocumented)
     (event: "valueChanged", listener: (op: ISharedArrayOperation, isLocal: boolean, target: IEventThisPlaceHolder) => void): void;
-    // (undocumented)
+    // @eventProperty (undocumented)
     (event: "revertible", listener: (revertible: IRevertible) => void): void;
 }
 
@@ -125,6 +126,12 @@ export type SerializableTypeForSharedArray = boolean | number | string | object
 // @alpha @legacy
 export type SerializableTypeForSharedSignal = boolean | number | string | IFluidHandle | object;
 
+// @alpha @legacy
+export const SharedArray: ISharedObjectKind<ISharedArray<SerializableTypeForSharedArray>> & SharedObjectKind<ISharedArray<SerializableTypeForSharedArray>>;
+
+// @alpha @legacy
+export const SharedArrayBuilder: <T extends SerializableTypeForSharedArray>() => ISharedObjectKind<ISharedArray<T>> & SharedObjectKind<ISharedArray<T>>;
+
 // @alpha @legacy
 export const SharedSignal: ISharedObjectKind<ISharedSignal<any>> & SharedObjectKind<ISharedSignal<any>>;
 

packages/dds/legacy-dds/api-report/legacy-dds.legacy.alpha.api.md

@@ -3,15 +3,17 @@
  * Licensed under the MIT License.
  */
 
-export { SharedArray } from "./sharedArray.js";
-export { SharedArrayFactory } from "./sharedArrayFactory.js";
+export {
+	SharedArrayFactory,
+	SharedArray,
+	SharedArrayBuilder,
+} from "./sharedArrayFactory.js";
 export { SharedArrayRevertible } from "./sharedArrayRevertible.js";
 export type {
 	SerializableTypeForSharedArray,
 	ISharedArray,
 	ISharedArrayEvents,
 	ISharedArrayRevertible,
-	FullyReadonly,
 	IRevertible,
 } from "./interfaces.js";
 export type {
@@ -20,7 +22,7 @@ export type {
 	IDeleteOperation,
 	IMoveOperation,
 	ISharedArrayRevertibleOperation,
-	OperationType,
 	IToggleMoveOperation,
 	IToggleOperation,
 } from "./sharedArrayOperations.js";
+export { OperationType } from "./sharedArrayOperations.js";