@fluidframework/tree 2.33.2 → 2.40.0

package/src/core/schema-stored/index.ts

@@ -32,7 +32,7 @@ export {
 } from "./storedSchemaRepository.js";
 export { Multiplicity } from "./multiplicity.js";
 
-export type { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from "./format.js";
+export type { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from "./formatV1.js";
 
-import * as schemaFormat from "./format.js";
-export { schemaFormat };
+import * as schemaFormatV1 from "./formatV1.js";
+export { schemaFormatV1 };

package/src/core/schema-stored/schema.ts

@@ -13,7 +13,7 @@ import {
 	PersistedValueSchema,
 	type TreeNodeSchemaDataFormat,
 	type TreeNodeSchemaIdentifier,
-} from "./format.js";
+} from "./formatV1.js";
 import type { Multiplicity } from "./multiplicity.js";
 
 /**
@@ -126,7 +126,9 @@ export interface TreeFieldStoredSchema {
  *
  * @remarks
  * This mainly show up in:
+ *
  * 1. The root default field for documents.
+ *
  * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
  */
 export const forbiddenFieldKindIdentifier = "Forbidden";

package/src/core/schema-stored/storedSchemaRepository.ts

@@ -9,7 +9,7 @@ import type { Listenable } from "@fluidframework/core-interfaces/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { compareStrings } from "../../util/index.js";
 
-import type { TreeNodeSchemaIdentifier } from "./format.js";
+import type { TreeNodeSchemaIdentifier } from "./formatV1.js";
 import {
 	type StoredSchemaCollection,
 	type TreeFieldStoredSchema,

package/src/core/schema-view/index.ts

@@ -7,5 +7,4 @@ export {
 	type Adapters,
 	type TreeAdapter,
 	AdaptedViewSchema,
-	AllowedUpdateType,
 } from "./view.js";

package/src/core/schema-view/view.ts

@@ -9,37 +9,6 @@ import type { TreeNodeSchemaIdentifier, TreeStoredSchema } from "../schema-store
  * APIs for applying `view schema` to documents.
  */
 
-/**
- * What kinds of updates to stored schema to permit.
- *
- * Bit flags enum.
- */
-export enum AllowedUpdateType {
-	/**
-	 * Do not update the stored schema to match view schema.
-	 */
-	None = 0,
-	/**
-	 * Update the stored schema as part of initializing an empty document.
-	 *
-	 * Includes "Initialize".
-	 */
-	// eslint-disable-next-line no-bitwise
-	Initialize = 1 << 0,
-	/**
-	 * Update the stored schema to match the view schema if the current document contents are compatible with the view schema.
-	 * TODO: support this option.
-	 */
-	// DataCompatible,
-	/**
-	 * Update the stored schema to match view schema if all possible documents based on the current stored schema would be compatible with the view schema.
-	 *
-	 * Includes "Initialize".
-	 */
-	// eslint-disable-next-line no-bitwise
-	SchemaCompatible = 1 << 1,
-}
-
 /**
  */
 export interface TreeAdapter {

package/src/core/tree/persistedTreeTextFormat.ts

@@ -5,7 +5,7 @@
 
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 
-import { schemaFormat } from "../schema-stored/index.js";
+import { schemaFormatV1 } from "../schema-stored/index.js";
 
 /**
  * This module contains persisted types for a simple, human-readable tree format.
@@ -58,7 +58,7 @@ const EncodedFieldMapObject = <Schema extends TSchema>(tChild: Schema) =>
 type EncodedNodeData = Static<typeof EncodedNodeData>;
 const EncodedNodeData = Type.Object({
 	value: Type.Optional(Type.Any()),
-	type: Type.Readonly(schemaFormat.TreeNodeSchemaIdentifierSchema),
+	type: Type.Readonly(schemaFormatV1.TreeNodeSchemaIdentifierSchema),
 });
 
 /**

package/src/feature-libraries/forest-summary/format.ts

@@ -6,14 +6,14 @@
 import { type Static, Type } from "@sinclair/typebox";
 
 import { Versioned } from "../../codec/index.js";
-import { schemaFormat } from "../../core/index.js";
+import { schemaFormatV1 } from "../../core/index.js";
 
 export const version = 1.0;
 
 export const Format = Type.Object(
 	{
 		version: Type.Literal(version),
-		keys: Type.Array(schemaFormat.FieldKeySchema),
+		keys: Type.Array(schemaFormatV1.FieldKeySchema),
 		fields: Versioned,
 	},
 	{ additionalProperties: false },

package/src/feature-libraries/index.ts

@@ -17,7 +17,13 @@ export {
 	mapTreeFieldFromCursor,
 } from "./mapTreeCursor.js";
 export { buildForest } from "./object-forest/index.js";
-export { SchemaSummarizer, encodeTreeSchema, makeSchemaCodec } from "./schema-index/index.js";
+export {
+	SchemaSummarizer,
+	encodeTreeSchema,
+	makeSchemaCodec,
+	makeSchemaCodecs,
+	SchemaCodecVersion,
+} from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
 	type CursorAdapter,

package/src/feature-libraries/mapTreeCursor.ts

@@ -26,17 +26,17 @@ import {
 } from "./treeCursorUtils.js";
 
 /**
- * @returns An {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
+ * Returns an {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
  */
 export function cursorForMapTreeNode(root: MapTree): CursorWithNode<MapTree> {
 	return stackTreeNodeCursor(adapter, root);
 }
 
 /**
- * @returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
+ * Returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
  */
 export function cursorForMapTreeField(
-	root: MapTree[],
+	root: readonly MapTree[],
 	detachedField: DetachedField = rootField,
 ): CursorWithNode<MapTree> {
 	const key = detachedFieldAsKey(detachedField);

package/src/feature-libraries/modular-schema/modularChangeFormat.ts

@@ -5,7 +5,7 @@
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 
-import { type ChangesetLocalId, RevisionTagSchema, schemaFormat } from "../../core/index.js";
+import { type ChangesetLocalId, RevisionTagSchema, schemaFormatV1 } from "../../core/index.js";
 import {
 	type JsonCompatibleReadOnly,
 	JsonCompatibleReadOnlySchema,
@@ -27,8 +27,8 @@ export type EncodedChangeAtomId = Static<typeof EncodedChangeAtomId>;
 
 const EncodedFieldChange = Type.Object(
 	{
-		fieldKey: schemaFormat.FieldKeySchema,
-		fieldKind: schemaFormat.FieldKindIdentifierSchema,
+		fieldKey: schemaFormatV1.FieldKeySchema,
+		fieldKind: schemaFormatV1.FieldKindIdentifierSchema,
 		// Implementation note: node and field change encoding is mutually recursive.
 		// This field marks a boundary in that recursion to avoid constructing excessively complex
 		// recursive types. Encoded changes are validated at this boundary at runtime--see modularChangeCodecs.ts.

package/src/feature-libraries/schema-edits/schemaChangeCodecs.ts

@@ -10,21 +10,50 @@ import {
 	type ICodecOptions,
 	type IJsonCodec,
 	makeCodecFamily,
+	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { makeSchemaCodec } from "../schema-index/index.js";
+import {
+	makeSchemaCodec,
+	SchemaCodecVersion,
+	type Format as FormatV1,
+} from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
 
+/**
+ * Create a family of schema change codecs.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The composed codec family.
+ */
 export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
-	return makeCodecFamily([[1, makeSchemaChangeCodec(options)]]);
+	return makeCodecFamily([[SchemaCodecVersion.v1, makeSchemaChangeCodecV1(options)]]);
+}
+
+/**
+ * Create a schema change codec.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @param writeVersion - The schema change write version.
+ * @returns The composed codec.
+ */
+export function makeSchemaChangeCodec(
+	options: ICodecOptions,
+	writeVersion: SchemaCodecVersion,
+): IJsonCodec<SchemaChange> {
+	const family = makeSchemaChangeCodecs(options);
+	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
 }
 
-function makeSchemaChangeCodec({
-	jsonValidator: validator,
-}: ICodecOptions): IJsonCodec<SchemaChange, EncodedSchemaChange> {
-	const schemaCodec = makeSchemaCodec({ jsonValidator: validator });
+/**
+ * Compose the v1 schema change codec.
+ * @param options - The codec options.
+ * @returns The composed schema change codec.
+ */
+function makeSchemaChangeCodecV1(
+	options: ICodecOptions,
+): IJsonCodec<SchemaChange, EncodedSchemaChange> {
+	const schemaCodec = makeSchemaCodec(options, SchemaCodecVersion.v1);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
 		encode: (schemaChange) => {
 			assert(
@@ -32,8 +61,8 @@ function makeSchemaChangeCodec({
 				0x933 /* Inverse schema changes should never be transmitted */,
 			);
 			return {
-				new: schemaCodec.encode(schemaChange.schema.new),
-				old: schemaCodec.encode(schemaChange.schema.old),
+				new: schemaCodec.encode(schemaChange.schema.new) as FormatV1,
+				old: schemaCodec.encode(schemaChange.schema.old) as FormatV1,
 			};
 		},
 		decode: (encoded) => {
@@ -48,5 +77,5 @@ function makeSchemaChangeCodec({
 		encodedSchema: EncodedSchemaChange,
 	};
 
-	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, validator);
+	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, options.jsonValidator);
 }

package/src/feature-libraries/schema-edits/schemaChangeFormat.ts

@@ -4,12 +4,11 @@
  */
 
 import { type Static, Type } from "@sinclair/typebox";
-
-import { Format } from "../schema-index/index.js";
+import { Format as FormatV1 } from "../schema-index/index.js";
 
 export const EncodedSchemaChange = Type.Object({
-	new: Format,
-	old: Format,
+	new: FormatV1,
+	old: FormatV1,
 });
 
 export type EncodedSchemaChange = Static<typeof EncodedSchemaChange>;

package/src/feature-libraries/schema-index/codec.ts

@@ -3,10 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { fail } from "@fluidframework/core-utils/internal";
+import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import {
+	type FluidClientVersion,
+	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
+	makeCodecFamily,
+	makeVersionDispatchingCodec,
 	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import {
@@ -15,15 +19,77 @@ import {
 	type TreeStoredSchema,
 	decodeFieldSchema,
 	encodeFieldSchema,
-	schemaFormat,
+	schemaFormatV1,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
-import { brand } from "../../util/index.js";
+import { brand, type JsonCompatible } from "../../util/index.js";
 
-import { Format } from "./format.js";
+import { Format as FormatV1 } from "./formatV1.js";
 
-export function encodeRepo(repo: TreeStoredSchema): Format {
-	const nodeSchema: Record<string, schemaFormat.TreeNodeSchemaDataFormat> =
+/**
+ * Versions for the codec that encodes an in-memory representation of a stored schema {@link TreeStoredSchema} into a persisted format (or decodes it in the opposite direction).
+ */
+export enum SchemaCodecVersion {
+	v1 = 1,
+}
+
+/**
+ * Convert a FluidClientVersion to a SchemaCodecVersion.
+ * @param clientVersion - The FluidClientVersion to convert.
+ * @returns The SchemaCodecVersion that corresponds to the provided FluidClientVersion.
+ */
+export function clientVersionToSchemaVersion(
+	clientVersion: FluidClientVersion,
+): SchemaCodecVersion {
+	// Only one version of the schema codec is currently supported.
+	return SchemaCodecVersion.v1;
+}
+
+/**
+ * Create a schema codec.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @param writeVersion - The schema write version.
+ * @returns The composed codec.
+ *
+ * @privateRemarks We should consider using the Shared Tree format version instead as it may be more valuable for application authors than the schema version.
+ */
+export function makeSchemaCodec(
+	options: ICodecOptions,
+	writeVersion: SchemaCodecVersion,
+): IJsonCodec<TreeStoredSchema> {
+	const family = makeSchemaCodecs(options);
+	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
+}
+
+/**
+ * Create a family of schema codecs.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The composed codec family.
+ */
+export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
+	return makeCodecFamily([[SchemaCodecVersion.v1, makeSchemaCodecV1(options)]]);
+}
+
+/**
+ * Encode an in-memory TreeStoredSchema into the specified format version.
+ * @param repo - The in-memory schema.
+ * @param version - The schema write version.
+ * @returns The encoded schema.
+ */
+export function encodeRepo(
+	repo: TreeStoredSchema,
+	version: SchemaCodecVersion,
+): JsonCompatible {
+	switch (version) {
+		case SchemaCodecVersion.v1:
+			return encodeRepoV1(repo);
+		default:
+			unreachableCase(version);
+	}
+}
+
+function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
+	const nodeSchema: Record<string, schemaFormatV1.TreeNodeSchemaDataFormat> =
 		Object.create(null);
 	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
@@ -36,13 +102,13 @@ export function encodeRepo(repo: TreeStoredSchema): Format {
 		});
 	}
 	return {
-		version: schemaFormat.version,
+		version: schemaFormatV1.version,
 		nodes: nodeSchema,
 		root: rootFieldSchema,
 	};
 }
 
-function decode(f: Format): TreeStoredSchema {
+function decode(f: FormatV1): TreeStoredSchema {
 	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
 	for (const [key, schema] of Object.entries(f.nodes)) {
 		nodeSchema.set(brand(key), storedSchemaDecodeDispatcher.dispatch(schema));
@@ -55,10 +121,12 @@ function decode(f: Format): TreeStoredSchema {
 
 /**
  * Creates a codec which performs synchronous monolithic encoding of schema content.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The codec.
  */
-export function makeSchemaCodec(options: ICodecOptions): IJsonCodec<TreeStoredSchema, Format> {
-	return makeVersionedValidatedCodec(options, new Set([schemaFormat.version]), Format, {
-		encode: (data: TreeStoredSchema) => encodeRepo(data),
-		decode: (data: Format) => decode(data),
+function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
+	return makeVersionedValidatedCodec(options, new Set([schemaFormatV1.version]), FormatV1, {
+		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
+		decode: (data: FormatV1) => decode(data),
 	});
 }

package/src/feature-libraries/schema-index/{format.ts → formatV1.ts}

@@ -5,7 +5,7 @@
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 
-import { schemaFormat } from "../../core/index.js";
+import { schemaFormatV1 } from "../../core/index.js";
 
 const noAdditionalProps: ObjectOptions = { additionalProperties: false };
 
@@ -21,9 +21,9 @@ const noAdditionalProps: ObjectOptions = { additionalProperties: false };
  */
 export const Format = Type.Object(
 	{
-		version: Type.Literal(schemaFormat.version),
-		nodes: Type.Record(Type.String(), schemaFormat.TreeNodeSchemaDataFormat),
-		root: schemaFormat.FieldSchemaFormat,
+		version: Type.Literal(schemaFormatV1.version),
+		nodes: Type.Record(Type.String(), schemaFormatV1.TreeNodeSchemaDataFormat),
+		root: schemaFormatV1.FieldSchemaFormat,
 	},
 	noAdditionalProps,
 );

package/src/feature-libraries/schema-index/index.ts

@@ -4,5 +4,10 @@
  */
 
 export { SchemaSummarizer, encodeTreeSchema } from "./schemaSummarizer.js";
-export { makeSchemaCodec } from "./codec.js";
-export { Format } from "./format.js";
+export {
+	makeSchemaCodec,
+	makeSchemaCodecs,
+	SchemaCodecVersion,
+	clientVersionToSchemaVersion,
+} from "./codec.js";
+export { Format } from "./formatV1.js";

package/src/feature-libraries/schema-index/schemaSummarizer.ts

@@ -14,7 +14,7 @@ import type {
 } from "@fluidframework/runtime-definitions/internal";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 
-import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import type { IJsonCodec } from "../../codec/index.js";
 import {
 	type MutableTreeStoredSchema,
 	type TreeStoredSchema,
@@ -27,8 +27,8 @@ import type {
 } from "../../shared-tree-core/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
-import { encodeRepo, makeSchemaCodec } from "./codec.js";
-import type { Format } from "./format.js";
+import { encodeRepo } from "./codec.js";
+import type { JsonCompatible } from "../../util/index.js";
 
 const schemaStringKey = "SchemaString";
 /**
@@ -37,16 +37,13 @@ const schemaStringKey = "SchemaString";
 export class SchemaSummarizer implements Summarizable {
 	public readonly key = "Schema";
 
-	private readonly codec: IJsonCodec<TreeStoredSchema, Format>;
-
 	private schemaIndexLastChangedSeq: number | undefined;
 
 	public constructor(
 		private readonly schema: MutableTreeStoredSchema,
-		options: ICodecOptions,
 		collabWindow: CollabWindow,
+		private readonly codec: IJsonCodec<TreeStoredSchema>,
 	) {
-		this.codec = makeSchemaCodec(options);
 		this.schema.events.on("afterSchemaChange", () => {
 			// Invalidate the cache, as we need to regenerate the blob if the schema changes
 			// We are assuming that schema changes from remote ops are valid, as we are in a summarization context.
@@ -116,6 +113,9 @@ export class SchemaSummarizer implements Summarizable {
  * @remarks
  * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
  */
-export function encodeTreeSchema(schema: TreeStoredSchema): Format {
-	return encodeRepo(schema);
+export function encodeTreeSchema(
+	schema: TreeStoredSchema,
+	writeVersion: number,
+): JsonCompatible {
+	return encodeRepo(schema, writeVersion);
 }

package/src/index.ts

@@ -152,6 +152,20 @@ export {
 	type FactoryContentObject,
 	type ReadableField,
 	type ReadSchema,
+	type ImplicitAnnotatedAllowedTypes,
+	type ImplicitAnnotatedFieldSchema,
+	type AnnotatedAllowedType,
+	type AnnotatedAllowedTypes,
+	type AllowedTypeMetadata,
+	type AllowedTypesMetadata,
+	type InsertableObjectFromAnnotatedSchemaRecord,
+	type UnannotateImplicitAllowedTypes,
+	type UnannotateAllowedTypes,
+	type UnannotateAllowedType,
+	type UnannotateAllowedTypesList,
+	type UnannotateAllowedTypeOrLazyItem,
+	type UnannotateImplicitFieldSchema,
+	type UnannotateSchemaRecord,
 	// test recursive schema for checking that d.ts files handles schema correctly
 	test_RecursiveObject,
 	test_RecursiveObject_base,
@@ -232,12 +246,15 @@ export {
 	type MapNodePojoEmulationSchema,
 	MapNodeSchema,
 	type ObjectFromSchemaRecord,
+	type ValidateRecursiveSchemaTemplate,
+	type FixRecursiveRecursionLimit,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
 	configuredSharedTree,
 } from "./treeFactory.js";
 export { SharedTreeAttributes, SharedTreeFactoryType } from "./sharedTreeAttributes.js";
+export { persistedToSimpleSchema } from "./shared-tree/index.js";
 
 export {
 	type ICodecOptions,
@@ -286,4 +303,4 @@ export type { MapNodeInsertableData } from "./simple-tree/index.js";
 
 export { JsonAsTree } from "./jsonDomainSchema.js";
 export { FluidSerializableAsTree } from "./serializableDomainSchema.js";
-export { TableSchema } from "./tableSchema.js";
+export { TableSchema, type System_TableSchema } from "./tableSchema.js";

package/src/internalTypes.ts

@@ -19,5 +19,3 @@ export type {
 	InsertableObjectFromSchemaRecord,
 } from "./simple-tree/index.js";
 export type { FlexList, FlexListToUnion, ExtractItemType } from "./simple-tree/index.js";
-
-export type { TreeApi } from "./shared-tree/index.js";

package/src/jsonDomainSchema.ts

@@ -36,7 +36,7 @@ const sf = new SchemaFactory("com.fluidframework.json");
  *
  * 2. The order of fields on an object is not preserved. The resulting order is arbitrary.
  *
- * JSON data can be imported from JSON into this format using `JSON.parse` then {@link TreeAlpha.importConcise} with the {@link JsonAsTree.(Tree:variable)} schema.
+ * JSON data can be imported from JSON into this format using `JSON.parse` then {@link (TreeAlpha:interface).importConcise} with the {@link JsonAsTree.(Tree:variable)} schema.
  *
  * @alpha
  */
@@ -125,7 +125,7 @@ export namespace JsonAsTree {
 	/**
 	 * Arbitrary JSON array as a {@link TreeNode}.
 	 * @remarks
-	 * This can be imported using {@link TreeAlpha.importConcise}.
+	 * This can be imported using {@link (TreeAlpha:interface).importConcise}.
 	 * @example
 	 * ```typescript
 	 * // Due to TypeScript restrictions on recursive types, the constructor can be somewhat limiting.

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.33.2";
+export const pkgVersion = "2.40.0";

package/src/serializableDomainSchema.ts

@@ -21,14 +21,14 @@ const sf = new SchemaFactory("com.fluidframework.serializable");
  * @remarks
  * Schema which replicate the Fluid Serializable data model with {@link TreeNode}s.
  *
- * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link TreeAlpha.importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
+ * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link (TreeAlpha:interface).importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
  * @internal
  */
 export namespace FluidSerializableAsTree {
 	/**
 	 * Data which can be serialized by Fluid.
 	 * @remarks
-	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link TreeAlpha.importConcise}.
+	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link (TreeAlpha:interface).importConcise}.
 	 * @internal
 	 */
 	export type Data = JsonCompatible<IFluidHandle>;
@@ -100,7 +100,7 @@ export namespace FluidSerializableAsTree {
 	/**
 	 * Arbitrary Fluid Serializable array as a {@link TreeNode}.
 	 * @remarks
-	 * This can be imported using {@link TreeAlpha.importConcise}.
+	 * This can be imported using {@link (TreeAlpha:interface).importConcise}.
 	 * @example
 	 * ```typescript
 	 * // Due to TypeScript restrictions on recursive types, the constructor can be somewhat limiting.

package/src/shared-tree/independentView.ts

@@ -23,9 +23,10 @@ import {
 	defaultSchemaPolicy,
 	TreeCompressionStrategy,
 	initializeForest,
+	SchemaCodecVersion,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
-import type { Format } from "../feature-libraries/schema-index/format.js";
+import type { Format } from "../feature-libraries/schema-index/formatV1.js";
 import type {
 	TreeViewConfiguration,
 	ImplicitFieldSchema,
@@ -92,7 +93,7 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	const revisionTagCodec = new RevisionTagCodec(idCompressor);
 
 	const fieldBatchCodec = makeFieldBatchCodec(options, 1);
-	const schemaCodec = makeSchemaCodec(options);
+	const schemaCodec = makeSchemaCodec(options, SchemaCodecVersion.v1);
 
 	const schema = new TreeStoredSchemaRepository(schemaCodec.decode(content.schema as Format));
 	const forest = buildConfiguredForest(
@@ -134,7 +135,7 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
  */
 export interface ViewContent {
 	/**
-	 * Compressed tree from {@link TreeAlpha.exportCompressed}.
+	 * Compressed tree from {@link (TreeAlpha:interface).exportCompressed}.
 	 * @remarks
 	 * This is an owning reference:
 	 * consumers of this content might modify this data in place (for example when applying edits) to avoid copying.

package/src/shared-tree/index.ts

@@ -21,6 +21,8 @@ export {
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
 	exportSimpleSchema,
+	type SharedTreeKernelView,
+	persistedToSimpleSchema,
 } from "./sharedTree.js";
 
 export {
@@ -45,13 +47,10 @@ export type {
 	SharedTreeEditBuilder,
 } from "./sharedTreeEditBuilder.js";
 
-export {
-	treeApi as Tree,
-	type TreeApi,
-	type RunTransaction,
-} from "./treeApi.js";
+export { Tree } from "./tree.js";
+export type { RunTransaction } from "./tree.js";
 
-export { TreeAlpha } from "./treeApiAlpha.js";
+export { TreeAlpha } from "./treeAlpha.js";
 
 export {
 	independentInitializedView,