@fluidframework/tree 2.112.0 → 2.113.1

package/src/simple-tree/api/configuration.ts

@@ -11,6 +11,7 @@ import type { MakeNominal } from "../../util/index.js";
 import {
 	type AllowedTypesFullEvaluated,
 	NodeKind,
+	StagedSchemaUpgradePolicy,
 	type TreeNodeSchema,
 } from "../core/index.js";
 import { type FieldSchemaAlpha, type ImplicitFieldSchema, FieldKind } from "../fieldSchema.js";
@@ -155,6 +156,35 @@ export interface ITreeViewConfiguration<
 	readonly schema: TSchema;
 }
 
+/**
+ * Property-bag configuration for {@link TreeViewConfigurationAlpha} construction.
+ * @alpha
+ */
+export interface ITreeViewConfigurationAlpha<
+	TSchema extends ImplicitFieldSchema = ImplicitFieldSchema,
+> extends ITreeViewConfiguration<TSchema> {
+	/**
+	 * Policy for generating stored schema from the view schema.
+	 *
+	 * @remarks
+	 * If omitted or `undefined`, defaults to {@link StagedSchemaUpgradePolicyFactory.restrictive}
+	 * which does not enable any staged schema upgrades.
+	 *
+	 * If provided, this policy is used when generating stored schema to include in documents via
+	 * `initialize` / `upgradeSchema` as well as in {@link snapshotSchemaCompatibility} to validate
+	 * the compatibility of such documents.
+	 *
+	 * @example Enabling specific staged upgrades
+	 * ```typescript
+	 * const config = new TreeViewConfigurationAlpha({
+	 *   schema: MySchema,
+	 *   stagedUpgradePolicy: StagedSchemaUpgradePolicy.enabledStagedUpgrades(myUpgrade),
+	 * });
+	 * ```
+	 */
+	readonly stagedUpgradePolicy?: StagedSchemaUpgradePolicy;
+}
+
 /**
  * Configuration for {@link ViewableTree.viewWith}.
  * @sealed @public
@@ -252,14 +282,22 @@ export class TreeViewConfigurationAlpha<
 		SimpleNodeSchema<SchemaType.View> & TreeNodeSchema
 	>;
 
-	public constructor(props: ITreeViewConfiguration<TSchema>) {
+	/**
+	 * {@inheritDoc ITreeViewConfigurationAlpha.stagedUpgradePolicy}
+	 */
+	public readonly stagedUpgradePolicy: StagedSchemaUpgradePolicy;
+
+	public constructor(props: ITreeViewConfigurationAlpha<TSchema>) {
 		super(props);
 		const treeSchema = createTreeSchema(this.schema);
 		this.root = treeSchema.root;
 		this.definitions = treeSchema.definitions;
 
+		this.stagedUpgradePolicy =
+			props.stagedUpgradePolicy ?? StagedSchemaUpgradePolicy.restrictive;
+
 		// Eagerly perform these conversions to surface errors sooner.
-		toInitialSchema(this.root);
+		toInitialSchema(this.root, this.stagedUpgradePolicy);
 		transformSimpleSchema(treeSchema, toUnhydratedSchema);
 	}
 }

package/src/simple-tree/api/index.ts

@@ -6,6 +6,7 @@
 export type {
 	ITreeViewConfiguration,
 	ITreeConfigurationOptions,
+	ITreeViewConfigurationAlpha,
 } from "./configuration.js";
 export {
 	TreeViewConfiguration,

package/src/simple-tree/api/schemaCompatibilityTester.ts

@@ -4,6 +4,7 @@
  */
 
 import type { TreeStoredSchema } from "../../core/index.js";
+import type { SchemaUpgrade, StagedSchemaUpgradePolicy } from "../core/index.js";
 import { allowsRepoSuperset, defaultSchemaPolicy } from "../../feature-libraries/index.js";
 import { toUpgradeSchema } from "../toStoredSchema.js";
 import type { TreeSchema } from "../treeSchema.js";
@@ -12,19 +13,22 @@ import { getDiscrepanciesInAllowedContent } from "./discrepancies.js";
 import type { SchemaCompatibilityStatus } from "./tree.js";
 
 /**
- * Determines the compatibility of a stored document
- * (based on its stored schema) with a viewer (based on its view schema).
+ * Determines the compatibility of a stored document (based on its stored schema) with a viewer (based on its view schema).
  *
- * @remarks
  * Adapters can be provided to handle differences between the two schema.
  * Adapters should only use to types in the `view` SchemaRepository.
  *
  * TODO: this API violates the parse don't validate design philosophy.
  * It should be wrapped with (or replaced by) a parse style API.
+ *
+ * @param viewSchema - Schema for the view
+ * @param stored - The stored schema to check compatibility against
+ * @param stagedSchemaUpgrades - Staged schema upgrades enabled for this view, or explicit stored-schema generation options
  */
 export function checkSchemaCompatibility(
 	viewSchema: TreeSchema,
 	stored: TreeStoredSchema,
+	stagedSchemaUpgrades?: Iterable<SchemaUpgrade> | StagedSchemaUpgradePolicy,
 ): Omit<SchemaCompatibilityStatus, "canInitialize"> {
 	// The public API surface assumes defaultSchemaPolicy
 	const policy = defaultSchemaPolicy;
@@ -40,7 +44,7 @@ export function checkSchemaCompatibility(
 		break;
 	}
 
-	const wouldUpgradeTo = toUpgradeSchema(viewSchema.root);
+	const wouldUpgradeTo = toUpgradeSchema(viewSchema.root, stagedSchemaUpgrades);
 
 	const canUpgrade = allowsRepoSuperset(policy, stored, wouldUpgradeTo);
 

package/src/simple-tree/api/tree.ts

@@ -444,7 +444,7 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 	/**
 	 * Description of the current compatibility status between the view schema and stored schema.
 	 * @remarks
-	 * {@link TreeViewEvents.schemaChanged} is fired when the compatibility status changes.
+	 * {@link TreeViewEvents.schemaChanged} is fired when the compatibility status of the document's stored schema changes.
 	 * See {@link https://fluidframework.com/docs/data-structures/tree/schema-evolution/ | schema-evolution} for more guidance on how to change schema while maintaining compatibility.
 	 * Use {@link snapshotSchemaCompatibility} to write tests to validate that this compatibility behaves as desired across schema changes.
 	 */
@@ -459,6 +459,44 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 	 *
 	 * It is an error to call this when {@link SchemaCompatibilityStatus.canUpgrade} is false.
 	 * {@link SchemaCompatibilityStatus.canUpgrade} being true does not mean that an upgrade is required, nor that an upgrade will have any effect.
+	 *
+	 * When using {@link TreeViewConfigurationAlpha} with a {@link ITreeViewConfigurationAlpha.stagedUpgradePolicy},
+	 * staged schema upgrades matching the configured policy are included in the target stored schema.
+	 * Once a staged schema upgrade has been enabled in a document's stored schema, loading that document
+	 * with a view that does not include equivalent staged members in its construction-time policy will cause
+	 * `upgradeSchema` to throw a `UsageError` because the requested target would narrow the stored schema.
+	 *
+	 * @example Enabling a staged allowed type for documents, selected by a feature flag
+	 *
+	 * ```typescript
+	 * const sf = new SchemaFactoryBeta("my-app");
+	 *
+	 * class TaskItem extends sf.object("TaskItem", { title: sf.string }) {}
+	 * class ChecklistItem extends sf.object("ChecklistItem", { text: sf.string }) {}
+	 *
+	 * // `staged` wraps ChecklistItem so it can be enabled at runtime.
+	 * const stagedChecklist = SchemaFactoryBeta.staged(ChecklistItem);
+	 * const checklistUpgrade = stagedChecklist.metadata.stagedSchemaUpgrade;
+	 *
+	 * class AppSchema extends sf.object("AppSchema", {
+	 *   items: sf.array([TaskItem, stagedChecklist]),
+	 * }) {}
+	 *
+	 * // Feature flag controls whether the upgrade is enabled for this session.
+	 * const policy = featureFlags.enableChecklist
+	 *   ? StagedSchemaUpgradePolicy.enabledStagedUpgrades(checklistUpgrade)
+	 *   : undefined;
+	 *
+	 * const view = tree.viewWith(
+	 *   new TreeViewConfigurationAlpha({ schema: AppSchema, stagedUpgradePolicy: policy }),
+	 * );
+	 *
+	 * if (view.compatibility.canUpgrade) {
+	 *   // Writes the staged type into the document's stored schema.
+	 *   view.upgradeSchema();
+	 * }
+	 * ```
+	 *
 	 * @privateRemarks
 	 * In the future, more upgrade options could be provided here.
 	 * Some options that could be added:
@@ -476,8 +514,12 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 	/**
 	 * Initialize the tree, setting the stored schema to match this view's schema and setting the tree content.
 	 *
+	 * @remarks
 	 * Only valid to call when this view's {@link SchemaCompatibilityStatus.canInitialize} is true.
 	 *
+	 * When using {@link TreeViewConfigurationAlpha} with a {@link ITreeViewConfigurationAlpha.stagedUpgradePolicy},
+	 * staged schema upgrades matching the configured policy are included in the initial stored schema.
+	 *
 	 * Applications should typically call this function before attaching a `SharedTree`.
 	 * @param content - The content to initialize the tree with.
 	 */
@@ -585,6 +627,21 @@ export interface TreeViewAlpha<
 
 	set root(newRoot: InsertableField<TSchema>);
 
+	/**
+	 * Initialize the tree, setting the stored schema to match this view's schema and setting the tree content.
+	 *
+	 * @remarks
+	 * Only valid to call when this view's {@link SchemaCompatibilityStatus.canInitialize} is true.
+	 *
+	 * Enables staged schema upgrades declared by {@link ITreeViewConfigurationAlpha.stagedUpgradePolicy} when generating the initial stored schema.
+	 * Once a staged schema upgrade has been enabled in a document's stored schema, loading that document
+	 * with a view that does not include equivalent staged members in its construction-time policy will cause
+	 * a subsequent `upgradeSchema` call to throw a `UsageError` because the stored schema already contains
+	 * the upgraded members and the new target would narrow it.
+	 *
+	 * Applications should typically call this function before attaching a `SharedTree`.
+	 * @param content - The content to initialize the tree with.
+	 */
 	initialize(content: InsertableField<TSchema>): void;
 
 	readonly events: Listenable<TreeViewEvents & TreeBranchEvents>;

package/src/simple-tree/core/index.ts

@@ -115,7 +115,8 @@ export {
 export type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
 export {
 	type StoredSchemaGenerationOptions,
-	type StoredFromViewSchemaGenerationOptions,
+	StagedSchemaUpgradePolicy,
+	type StagedSchemaUpgradePolicyFactory,
 	ExpectStored,
 	type SimpleSchemaTransformationOptions,
 	Unchanged,

package/src/simple-tree/core/toStored.ts

@@ -6,18 +6,20 @@
 import type { SchemaUpgrade } from "./allowedTypes.js";
 
 /**
- * Options for transforming a view simple-schema to a stored simple-schema (See {@link TreeStoredSchema}).
+ * Policy controlling which staged schema upgrades are included when generating stored schema from a view schema.
+ * @input
+ * @alpha
  */
-export interface StoredFromViewSchemaGenerationOptions {
+export interface StagedSchemaUpgradePolicy {
 	/**
-	 * Determines whether to include {@link SchemaStaticsBeta.staged | staged} allowed types in the resulting stored schema.
+	 * Determines whether to include staged allowed types in the resulting stored schema.
 	 * @remarks
 	 * Due to caching, the behavior of this function must be pure.
 	 */
 	includeStaged(upgrade: SchemaUpgrade): boolean;
 
 	/**
-	 * Determines whether to treat a {@link SchemaFactoryAlpha.stagedOptional | staged optional} field as optional
+	 * Determines whether to treat a staged optional field as optional
 	 * (rather than required) in the resulting stored schema.
 	 * @remarks
 	 * Due to caching, the behavior of this function must be pure.
@@ -25,6 +27,93 @@ export interface StoredFromViewSchemaGenerationOptions {
 	includeStagedOptional(upgrade: SchemaUpgrade): boolean;
 }
 
+/**
+ * Provides factory methods for creating {@link (StagedSchemaUpgradePolicy:interface)} instances.
+ *
+ * @remarks
+ * Use the properties and methods on this object to obtain staged-schema generation options
+ * for different scenarios:
+ *
+ * - {@link StagedSchemaUpgradePolicyFactory.restrictive} — no staged upgrades (default)
+ *
+ * - {@link StagedSchemaUpgradePolicyFactory.permissive} — all staged upgrades enabled
+ *
+ * - {@link StagedSchemaUpgradePolicyFactory.enabledStagedUpgrades} — only specific upgrades enabled
+ *
+ * @example
+ * ```typescript
+ * // Enable specific upgrades:
+ * const options = StagedSchemaUpgradePolicy.enabledStagedUpgrades(myUpgrade);
+ *
+ * // Use restrictive (default, no staged upgrades):
+ * const options = StagedSchemaUpgradePolicy.restrictive;
+ *
+ * // Use permissive (all staged upgrades, useful for testing):
+ * const options = StagedSchemaUpgradePolicy.permissive;
+ * ```
+ *
+ * @sealed
+ * @alpha
+ */
+export interface StagedSchemaUpgradePolicyFactory {
+	/**
+	 * Restrictive policy — excludes all staged schema members.
+	 *
+	 * @remarks
+	 * Use this when you want the most conservative stored schema for compatibility-sensitive
+	 * scenarios, or when staged schema upgrades should remain disabled.
+	 *
+	 * This is the default behavior when no staged upgrades are enabled.
+	 */
+	readonly restrictive: StagedSchemaUpgradePolicy;
+	/**
+	 * Permissive policy — includes all staged schema upgrades.
+	 *
+	 * @remarks
+	 * Use this for testing, validation, and rollout rehearsal scenarios where you want to exercise
+	 * future document shapes before enabling staged upgrades broadly.
+	 */
+	readonly permissive: StagedSchemaUpgradePolicy;
+	/**
+	 * Creates options that include only the specified staged schema upgrades.
+	 *
+	 * @param upgrades - The staged schema upgrades to enable.
+	 * @returns Options that include only the specified upgrades.
+	 *
+	 * @remarks
+	 * If an empty set of upgrades is passed, the result is equivalent to
+	 * `StagedSchemaUpgradePolicy.restrictive`.
+	 */
+	enabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy;
+}
+
+/**
+ * {@inheritDoc (StagedSchemaUpgradePolicyFactory:interface)}
+ * @alpha
+ */
+export const StagedSchemaUpgradePolicy: StagedSchemaUpgradePolicyFactory = {
+	restrictive: {
+		includeStaged: () => false,
+		includeStagedOptional: () => false,
+	},
+
+	permissive: {
+		includeStaged: () => true,
+		includeStagedOptional: () => true,
+	},
+
+	enabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy {
+		if (upgrades.length === 0) {
+			return StagedSchemaUpgradePolicy.restrictive;
+		}
+		const enabledUpgradeSet = new Set(upgrades);
+		return {
+			includeStaged: (upgrade) => enabledUpgradeSet.has(upgrade),
+			includeStagedOptional: (upgrade) => enabledUpgradeSet.has(upgrade),
+		};
+	},
+};
+
 /**
  * Marker type indicating that the input schema is already a stored schema.
  */
@@ -42,9 +131,7 @@ export type Unchanged = typeof Unchanged;
 /**
  * Subset of {@link SimpleSchemaTransformationOptions} for when the output is a known to be a stored schema.
  */
-export type StoredSchemaGenerationOptions =
-	| StoredFromViewSchemaGenerationOptions
-	| ExpectStored;
+export type StoredSchemaGenerationOptions = StagedSchemaUpgradePolicy | ExpectStored;
 
 /**
  * Options for transforming a schema.
@@ -54,6 +141,6 @@ export type StoredSchemaGenerationOptions =
  * we will need to add a "ToView" option here.
  */
 export type SimpleSchemaTransformationOptions =
-	| StoredFromViewSchemaGenerationOptions
+	| StagedSchemaUpgradePolicy
 	| ExpectStored
 	| Unchanged;

package/src/simple-tree/index.ts

@@ -59,6 +59,8 @@ export {
 	type AllowedTypesFullFromMixed,
 	AnnotatedAllowedTypesInternal,
 	type NumberKeys,
+	StagedSchemaUpgradePolicy,
+	type StagedSchemaUpgradePolicyFactory,
 	ExpectStored,
 	createSchemaUpgrade,
 } from "./core/index.js";
@@ -72,6 +74,7 @@ export {
 	TreeViewConfiguration,
 	TreeViewConfigurationAlpha,
 	type ITreeViewConfiguration,
+	type ITreeViewConfigurationAlpha,
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
 	SchemaFactory,
@@ -317,8 +320,6 @@ export {
 	toUpgradeSchema,
 	toInitialSchema,
 	toUnhydratedSchema,
-	restrictiveStoredSchemaGenerationOptions,
-	permissiveStoredSchemaGenerationOptions,
 } from "./toStoredSchema.js";
 export {
 	numberSchema,

package/src/simple-tree/prepareForInsertion.ts

@@ -155,6 +155,18 @@ function validateAndPrepare(
 	mapTrees: readonly UnhydratedFlexTreeNode[],
 	scheduleHydrationOverride?: HydrationScheduler,
 ): void {
+	// Detecting duplicates here is the lowest level spot which is the same for hydrated and un-hydrated parents,
+	// and is also responsible for other validation, so it seem like the best layer to do this check.
+	const seenRoots = new Set<UnhydratedFlexTreeNode>();
+	for (const node of mapTrees) {
+		if (seenRoots.has(node)) {
+			throw new UsageError(
+				`A ${JSON.stringify(node.type)} node was provided more than once in a single insertion. A node may not be in more than one place in the tree.`,
+			);
+		}
+		seenRoots.add(node);
+	}
+
 	if (hydratedData !== undefined) {
 		// Run `prepareContentForHydration` before walking the tree in `isFieldInSchema`.
 		// This ensures that when `isFieldInSchema` requests identifiers (or any other contextual defaults),

package/src/simple-tree/toStoredSchema.ts

@@ -37,9 +37,9 @@ import {
 	ExpectStored,
 	NodeKind,
 	SchemaUpgrade,
+	StagedSchemaUpgradePolicy,
 	Unchanged,
 	type SimpleSchemaTransformationOptions,
-	type StoredFromViewSchemaGenerationOptions,
 	type StoredSchemaGenerationOptions,
 } from "./core/index.js";
 import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./fieldSchema.js";
@@ -64,63 +64,68 @@ import { createTreeSchema } from "./treeSchema.js";
 // The simple-schema related logic from this file and src/simple-tree/core/toStored.ts can be unified and `toStoredSchema` and its other ImplicitFieldSchema consuming variants should probably be removed in favor of acting on TreeSchema and SimpleTreeSchema directly.
 
 const viewToStoredCache = new WeakMap<
-	StoredFromViewSchemaGenerationOptions,
+	StagedSchemaUpgradePolicy,
 	WeakMap<ImplicitFieldSchema, TreeStoredSchema>
 >();
 
-/**
- * Maximally restrictive transformation of a view to stored schema.
- * @remarks
- * This should only be used when the intent is to produce a stored schema is as restrictive as possible while still being compatible with the input view schema.
- * This is typically used for cases where backwards compatibility with past versions of an application is required, like {@link toUpgradeSchema} or {@link toInitialSchema}.
- */
-export const restrictiveStoredSchemaGenerationOptions: StoredFromViewSchemaGenerationOptions =
-	{
-		includeStaged: () => false,
-		includeStagedOptional: () => false,
-	};
+function isStagedSchemaUpgradePolicy(
+	stagedSchemaUpgrades: Iterable<SchemaUpgrade> | StagedSchemaUpgradePolicy,
+): stagedSchemaUpgrades is StagedSchemaUpgradePolicy {
+	return (
+		typeof stagedSchemaUpgrades === "object" &&
+		"includeStaged" in stagedSchemaUpgrades &&
+		"includeStagedOptional" in stagedSchemaUpgrades
+	);
+}
 
 /**
- * Maximally permissive transformation of a view to stored schema.
+ * Resolves a collection of staged schema upgrades into stored-schema generation options.
  * @remarks
- * This should only be used when the intent is to produce a stored schema which allows as much as possible while still being compatible with the input view schema.
- * This is typically used for cases where forwards compatibility with future versions of an application is required, like {@link toUnhydratedSchema}.
- *
- * This is unable to include unknown optional fields in the output, which makes it not truly maximally permissive.
- *
- * TODO: {@link StoredFromViewSchemaGenerationOptions} could be updated to allow a way to inject extra optional fields.
- * If done, then this could take in an existing stored schema, and attempt to generate a valid superset.
- * This could be useful to use as the schema for unhydrated content cloned from hydrated content.
+ * If `stagedSchemaUpgrades` is omitted, returns restrictive options.
  */
-export const permissiveStoredSchemaGenerationOptions: StoredFromViewSchemaGenerationOptions = {
-	includeStaged: () => true,
-	includeStagedOptional: () => true,
-};
+export function resolveStoredSchemaGenerationOptions(
+	stagedSchemaUpgrades?: Iterable<SchemaUpgrade> | StagedSchemaUpgradePolicy,
+): StagedSchemaUpgradePolicy {
+	if (stagedSchemaUpgrades === undefined) {
+		return StagedSchemaUpgradePolicy.restrictive;
+	}
+
+	if (isStagedSchemaUpgradePolicy(stagedSchemaUpgrades)) {
+		return stagedSchemaUpgrades;
+	}
+
+	return StagedSchemaUpgradePolicy.enabledStagedUpgrades(...stagedSchemaUpgrades);
+}
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} for use in schema upgrades.
- *
- * TODO: once upgrades are more flexible, this should take in more options, including the old schema and specific upgrades to enable.
  */
-export function toUpgradeSchema(root: ImplicitFieldSchema): TreeStoredSchema {
-	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
+export function toUpgradeSchema(
+	root: ImplicitFieldSchema,
+	stagedSchemaUpgrades?: Iterable<SchemaUpgrade> | StagedSchemaUpgradePolicy,
+): TreeStoredSchema {
+	return toStoredSchema(root, resolveStoredSchemaGenerationOptions(stagedSchemaUpgrades));
 }
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} for use as initial document schema.
  */
-export function toInitialSchema(root: ImplicitFieldSchema): TreeStoredSchema {
-	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
+export function toInitialSchema(
+	root: ImplicitFieldSchema,
+	stagedSchemaUpgrades?: Iterable<SchemaUpgrade> | StagedSchemaUpgradePolicy,
+): TreeStoredSchema {
+	return toStoredSchema(root, resolveStoredSchemaGenerationOptions(stagedSchemaUpgrades));
 }
 
 /**
- * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} to used for unhydrated nodes.
+ * Permissive staged schema upgrade policy used for unhydrated node schema generation.
  * @remarks
  * This allows as much as possible, relying on further validation when inserting the content.
  *
  * TODO: this should get additional options to enable support for unknown optional fields.
  */
-export const toUnhydratedSchema = permissiveStoredSchemaGenerationOptions;
+export const toUnhydratedSchema: StagedSchemaUpgradePolicy =
+	StagedSchemaUpgradePolicy.permissive;
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
@@ -137,7 +142,7 @@ export const toUnhydratedSchema = permissiveStoredSchemaGenerationOptions;
  */
 export function toStoredSchema(
 	root: ImplicitFieldSchema,
-	options: StoredFromViewSchemaGenerationOptions,
+	options: StagedSchemaUpgradePolicy,
 ): TreeStoredSchema {
 	const cache = getOrCreate(viewToStoredCache, options, () => new WeakMap());
 	return getOrCreate(cache, root, () => {
@@ -152,7 +157,7 @@ export function toStoredSchema(
  */
 export function transformSimpleSchema(
 	schema: SimpleTreeSchema<SchemaType.View>,
-	options: StoredFromViewSchemaGenerationOptions,
+	options: StagedSchemaUpgradePolicy,
 ): SimpleTreeSchema<SchemaType.Stored>;
 
 /**
@@ -324,7 +329,7 @@ export function getStoredSchema(
  */
 export function transformSimpleNodeSchema(
 	schema: SimpleNodeSchema<SchemaType.View>,
-	options: StoredFromViewSchemaGenerationOptions,
+	options: StagedSchemaUpgradePolicy,
 ): SimpleNodeSchema<SchemaType.Stored>;
 
 /**
@@ -483,7 +488,7 @@ function allowedTypeFilter(
 	if (options === ExpectStored) {
 		if (data.isStaged !== undefined) {
 			throw new UsageError(
-				"Failed to covert view schema to stored schema. The simple schema provided was indicated to be a stored schema by the use of `ExpectStored`, but view schema specific content was encountered which requires a `StoredFromViewSchemaGenerationOptions` to process.",
+				"Failed to covert view schema to stored schema. The simple schema provided was indicated to be a stored schema by the use of `ExpectStored`, but view schema specific content was encountered which requires a `StagedSchemaUpgradePolicy` to process.",
 			);
 		}
 		return true;
@@ -505,7 +510,7 @@ function allowedTypeFilter(
 
 function isStoredFromView(
 	options: SimpleSchemaTransformationOptions,
-): options is StoredFromViewSchemaGenerationOptions {
+): options is StagedSchemaUpgradePolicy {
 	return typeof options === "object" && "includeStaged" in options;
 }