@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/core/change-family/changeFamily.ts

@@ -14,17 +14,12 @@ export interface ChangeFamily<TEditor extends ChangeFamilyEditor, TChange> {
 	buildEditor(
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<TChange>) => void,
-		options?: EditorOptions,
 	): TEditor;
 
 	readonly rebaser: ChangeRebaser<TChange>;
 	readonly codecs: ICodecFamily<TChange, ChangeEncodingContext>;
 }
 
-export interface EditorOptions {
-	readonly canMakeDetachedRootEdits: boolean; // default is false,
-}
-
 export interface ChangeEncodingContext {
 	readonly originatorId: SessionId;
 	readonly revision: RevisionTag | undefined;

package/src/core/change-family/index.ts

@@ -8,6 +8,5 @@ export type {
 	ChangeFamilyEditor,
 	ChangeEncodingContext,
 	ChangeFamilyCodec,
-	EditorOptions,
 } from "./changeFamily.js";
 export { EditBuilder } from "./editBuilder.js";

package/src/core/index.ts

@@ -74,7 +74,7 @@ export {
 	type AnchorNode,
 	anchorSlot,
 	type UpPathDefault,
-	isDetachedUpPathRoot,
+	isDetachedUpPath,
 	inCursorField,
 	inCursorNode,
 	type AnchorEvents,
@@ -87,7 +87,6 @@ export {
 	type DetachedFieldIndexCheckpoint,
 	type ForestRootId,
 	getDetachedFieldContainingPath,
-	getDetachedFieldContainingFieldPath,
 	aboveRootPlaceholder,
 	type DeltaRoot,
 	type DeltaMark,
@@ -106,7 +105,7 @@ export {
 	tryGetChunk,
 	type ChunkedCursor,
 	DetachedFieldIndexFormatVersion,
-	getCodecTreeForDetachedFieldIndexFormat,
+	detachedFieldIndexCodecBuilder,
 } from "./tree/index.js";
 
 export {
@@ -163,7 +162,6 @@ export {
 	type ChangeEncodingContext,
 	type ChangeFamilyEditor,
 	EditBuilder,
-	type EditorOptions,
 } from "./change-family/index.js";
 
 export {
@@ -177,6 +175,7 @@ export {
 	type GraphCommit,
 	CommitKind,
 	type CommitMetadata,
+	type ChangeMetadata,
 	type RevisionTag,
 	RevisionTagSchema,
 	RevisionTagCodec,
@@ -205,16 +204,15 @@ export {
 	offsetChangeAtomId,
 	StableIdSchema,
 	subtractChangeAtomIds,
-	replaceAtomRevisions,
 	replaceChange,
 	type RebaseStats,
 	type RebaseStatsWithDuration,
 	isAncestor,
 	type ChangeAtomIdRangeMap,
 	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
 	compareRevisions,
 	diffHistories,
+	type RevisionReplacer,
 } from "./rebase/index.js";
 
 export {

package/src/core/rebase/changeRebaser.ts

@@ -5,7 +5,7 @@
 
 import type { Invariant } from "../../util/index.js";
 
-import type { RevisionTag } from "./types.js";
+import type { ChangeAtomId, RevisionTag } from "./types.js";
 
 /**
  * Rebasing logic for a particular kind of change.
@@ -89,11 +89,45 @@ export interface ChangeRebaser<TChangeset> {
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
-	changeRevision(
-		change: TChangeset,
-		newRevision: RevisionTag | undefined,
-		rollBackOf?: RevisionTag,
-	): TChangeset;
+	/**
+	 * Retrieves the set of revisions associated with the given change.
+	 */
+	getRevisions(change: TChangeset): Set<RevisionTag | undefined>;
+
+	/**
+	 * Produces a changeset that is equivalent to the given `change`, but with all references to its own revisions replaced according to the given `replacer`.
+	 * @param change - The change to update. Not modified.
+	 * @param replacer - The replacer to use.
+	 * @returns A changeset equivalent to `change`, but with all references to its own revision replaced according to `replacer`.
+	 */
+	changeRevision(change: TChangeset, replacer: RevisionReplacer): TChangeset;
+}
+
+/**
+ * A type that can update references to a set of obsolete revisions across multiple changesets.
+ */
+export interface RevisionReplacer {
+	/**
+	 * The revision to use in place of the obsolete revisions.
+	 */
+	readonly updatedRevision: RevisionTag;
+
+	/**
+	 * Predicate to determine if a revision needs replacing.
+	 * @param revision - The revision that may need replacing.
+	 * @returns true iff the given `revision` needs replacing.
+	 */
+	isObsolete(revision: RevisionTag | undefined): boolean;
+
+	/**
+	 * Returns the updated ID for the given ID.
+	 * @param id - The ID to update.
+	 * @returns an updated ID iff the given `id` needs updating, otherwise returns the given `id`.
+	 * @remarks
+	 * This function always maps the same input {@link ChangeAtomId.revision | revision} and {@link ChangeAtomId.localId | local ID} to the same output revision local ID.
+	 * This means multiple references to the same atom of change will remain consistent after revision replacement.
+	 */
+	getUpdatedAtomId<T extends ChangeAtomId>(id: T): T;
 }
 
 export interface TaggedChange<TChangeset, TTag = RevisionTag | undefined> {
@@ -126,12 +160,7 @@ export function mapTaggedChange<TIn, TOut>(
 export type RevisionIndexer = (tag: RevisionTag) => number | undefined;
 
 export interface RevisionMetadataSource {
-	/**
-	 * @returns a positive number if tag2 is a later revision than tag1 or a negative number if tag2 is an earlier revision.
-	 * Returns zero is the order cannot be determined, which happens if both revisions are older
-	 * than the set of revisions handled by this metadata source.
-	 */
-	readonly compareRevisions: (tag1: RevisionTag, tag2: RevisionTag) => number;
+	readonly getIndex: RevisionIndexer;
 	readonly tryGetInfo: (tag: RevisionTag | undefined) => RevisionInfo | undefined;
 	readonly hasRollback: (tag: RevisionTag) => boolean;
 }

package/src/core/rebase/index.ts

@@ -12,6 +12,7 @@ export {
 	type GraphCommit,
 	CommitKind,
 	type CommitMetadata,
+	type ChangeMetadata,
 	type RevisionTag,
 	RevisionTagSchema,
 	type EncodedRevisionTag,
@@ -26,10 +27,8 @@ export {
 	offsetChangeAtomId,
 	StableIdSchema,
 	subtractChangeAtomIds,
-	replaceAtomRevisions,
 	type ChangeAtomIdRangeMap,
 	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
 	compareRevisions,
 } from "./types.js";
 export { RevisionTagCodec } from "./revisionTagCodec.js";
@@ -44,6 +43,7 @@ export {
 	type TaggedChange,
 	type RevisionMetadataSource,
 	type RevisionInfo,
+	type RevisionReplacer,
 } from "./changeRebaser.js";
 export {
 	findAncestor,

package/src/core/rebase/types.ts

@@ -13,6 +13,7 @@ import { Type } from "@sinclair/typebox";
 
 import {
 	type Brand,
+	type JsonCompatibleReadOnly,
 	type NestedMap,
 	RangeMap,
 	brand,
@@ -120,35 +121,20 @@ export function taggedOptAtomId(
 	return taggedAtomId(id, revision);
 }
 
-export function offsetChangeAtomId<T extends ChangeAtomId = ChangeAtomId>(
-	id: T,
-	offset: number,
-): T {
+export function offsetChangeAtomId(id: ChangeAtomId, offset: number): ChangeAtomId {
 	return { ...id, localId: brand(id.localId + offset) };
 }
 
-export function replaceAtomRevisions(
-	id: ChangeAtomId,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): ChangeAtomId {
-	return oldRevisions.has(id.revision) ? atomWithRevision(id, newRevision) : id;
-}
-
-function atomWithRevision(id: ChangeAtomId, revision: RevisionTag | undefined): ChangeAtomId {
-	const updated = { ...id, revision };
-	if (revision === undefined) {
-		delete updated.revision;
-	}
-
-	return updated;
-}
-
 /**
  * A node in a graph of commits. A commit's parent is the commit on which it was based.
  */
 export interface GraphCommit<TChange> {
-	/** The tag for this commit. If this commit is rebased, the corresponding rebased commit will retain this tag. */
+	/**
+	 * The tag for this commit.
+	 * @remarks
+	 * If this commit is rebased, the corresponding rebased commit will retain this tag.
+	 * With the exception of transaction commits (which all share the same tag), this tag is unique within a given branch history.
+	 */
 	readonly revision: RevisionTag;
 	/** The change that will result from applying this commit */
 	readonly change: TChange;
@@ -186,6 +172,30 @@ export interface CommitMetadata {
 	readonly isLocal: boolean;
 }
 
+/**
+ * Information about a commit that has been applied.
+ *
+ * @sealed @alpha
+ */
+export type ChangeMetadata = CommitMetadata &
+	(
+		| {
+				readonly isLocal: true;
+				/**
+				 * A serializable object that encodes the change.
+				 * @remarks This change object can be {@link TreeBranchAlpha.applyChange | applied to another branch} in the same state as the one which generated it.
+				 * The change object must be applied to a SharedTree with the same IdCompressor session ID as it was created from.
+				 * @privateRemarks
+				 * This is a `SerializedChange` from treeCheckout.ts.
+				 */
+				getChange(): JsonCompatibleReadOnly;
+		  }
+		| {
+				readonly isLocal: false;
+				readonly getChange?: undefined;
+		  }
+	);
+
 /**
  * Creates a new graph commit object. This is useful for creating copies of commits with different parentage.
  * @param parent - the parent of the new commit
@@ -212,10 +222,6 @@ export function newChangeAtomIdRangeMap<V>(): ChangeAtomIdRangeMap<V> {
 	return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds);
 }
 
-export function newChangeAtomIdTransform(): ChangeAtomIdRangeMap<ChangeAtomId> {
-	return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetChangeAtomId);
-}
-
 export function subtractChangeAtomIds(a: ChangeAtomId, b: ChangeAtomId): number {
 	const cmp = compareRevisions(a.revision, b.revision);
 	if (cmp !== 0) {

package/src/core/rebase/utils.ts

@@ -200,7 +200,7 @@ export function rebaseBranch<TChange>(
 	const sourceBranchLength = sourcePath.length;
 
 	// Find where `targetCommit` is in the target branch
-	const targetCommitIndex = targetPath.findIndex((r) => r === targetCommit);
+	const targetCommitIndex = targetPath.indexOf(targetCommit);
 	if (targetCommitIndex === -1) {
 		// If the targetCommit is not in the target path, then it is either disjoint from `target` or it is behind/at
 		// the commit where source and target diverge (ancestor), in which case there is nothing more to rebase
@@ -292,7 +292,7 @@ export function rebaseBranch<TChange>(
 	const revInfos = getRevInfoFromTaggedChanges([...targetRebasePath, ...sourcePath]);
 	// Note that the `revisionMetadata` gets updated as `revInfos` gets updated.
 	const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
-	let editsToCompose: TaggedChange<TChange>[] = targetRebasePath.slice();
+	let editsToCompose: TaggedChange<TChange>[] = [...targetRebasePath];
 	for (const c of sourcePath) {
 		const rollback = rollbackFromCommit(changeRebaser, c, mintRevisionTag, true /* cache */);
 		if (sourceSet.has(c.revision)) {
@@ -327,9 +327,7 @@ export function rebaseBranch<TChange>(
 			},
 		},
 		"sourceChange",
-		() => {
-			return changeRebaser.compose(editsToCompose);
-		},
+		() => changeRebaser.compose(editsToCompose),
 	);
 }
 
@@ -377,45 +375,23 @@ export function rebaseChange<TChange>(
 export function revisionMetadataSourceFromInfo(
 	revInfos: readonly RevisionInfo[],
 ): RevisionMetadataSource {
-	const compareRevisions = (revision1: RevisionTag, revision2: RevisionTag): number => {
-		const index1 = getIndex(revision1);
-		const index2 = getIndex(revision2);
-
-		if (index1 !== undefined) {
-			return index2 !== undefined ? index2 - index1 : -1;
-		}
-
-		return index2 !== undefined ? 1 : 0;
+	const getIndex = (revision: RevisionTag): number | undefined => {
+		const index = revInfos.findIndex((revInfo) => revInfo.revision === revision);
+		return index >= 0 ? index : undefined;
 	};
-
 	const tryGetInfo = (revision: RevisionTag | undefined): RevisionInfo | undefined => {
 		if (revision === undefined) {
 			return undefined;
 		}
-		return revInfos.find((info) => info.revision === revision);
+		const index = getIndex(revision);
+		return index === undefined ? undefined : revInfos[index];
 	};
 
 	const hasRollback = (revision: RevisionTag): boolean => {
-		return revInfos.find((info) => info.rollbackOf === revision) !== undefined;
-	};
-
-	const getIndex = (revision: RevisionTag): number | undefined => {
-		const index = revInfos.findIndex((revInfo) => revInfo.revision === revision);
-		if (index >= 0) {
-			return index;
-		}
-
-		const rollbackIndex = revInfos.findIndex((revInfo) => revInfo.rollbackOf === revision);
-		if (rollbackIndex >= 0) {
-			// This change is the forward revision of a rollback included in revInfos, so it comes after
-			// all revisions in revInfos. Earlier rollbacks have later forward revisions.
-			return 2 * revInfos.length - rollbackIndex;
-		}
-
-		return undefined;
+		return revInfos.some((info) => info.rollbackOf === revision);
 	};
 
-	return { compareRevisions, tryGetInfo, hasRollback };
+	return { getIndex, tryGetInfo, hasRollback };
 }
 
 export function rebaseChangeOverChanges<TChange>(

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

@@ -7,11 +7,12 @@ import { fail } from "@fluidframework/core-utils/internal";
 
 import { DiscriminatedUnionDispatcher } from "../../codec/index.js";
 import {
-	type Brand,
 	type JsonCompatibleReadOnlyObject,
 	type MakeNominal,
+	type Values,
 	brandConst,
 	invertMap,
+	strictEnum,
 } from "../../util/index.js";
 
 import {
@@ -33,17 +34,14 @@ import type { Multiplicity } from "./multiplicity.js";
 /**
  * The format version for the schema.
  */
-export const SchemaFormatVersion = {
+export const SchemaFormatVersion = strictEnum("SchemaFormatVersion", {
 	v1: 1,
 	/**
 	 * Adds persisted metadata to the node schema and field schema.
 	 */
 	v2: 2,
-} as const;
-export type SchemaFormatVersion = Brand<
-	(typeof SchemaFormatVersion)[keyof typeof SchemaFormatVersion],
-	"SchemaFormatVersion"
->;
+});
+export type SchemaFormatVersion = Values<typeof SchemaFormatVersion>;
 
 type FieldSchemaFormat = FieldSchemaFormatV1 | FieldSchemaFormatV2;
 
@@ -396,9 +394,9 @@ export function encodeFieldSchemaV2(schema: TreeFieldStoredSchema): FieldSchemaF
 	const fieldSchema: FieldSchemaFormatV1 = encodeFieldSchemaV1(schema);
 
 	// Omit metadata from the output if it is undefined
-	return schema.persistedMetadata !== undefined
-		? { ...fieldSchema, metadata: schema.persistedMetadata }
-		: { ...fieldSchema };
+	return schema.persistedMetadata === undefined
+		? { ...fieldSchema }
+		: { ...fieldSchema, metadata: schema.persistedMetadata };
 }
 
 export function decodeFieldSchema(schema: FieldSchemaFormatV2): TreeFieldStoredSchema {

package/src/core/tree/anchorSet.ts

@@ -424,10 +424,8 @@ export class AnchorSet implements AnchorLocator {
 	 * Does not add a ref!
 	 */
 	public find(path: UpPath): PathNode | undefined {
-		if (path instanceof PathNode) {
-			if (path.anchorSet === this) {
-				return path;
-			}
+		if (path instanceof PathNode && path.anchorSet === this) {
+			return path;
 		}
 		const parent = path.parent ?? this.root;
 		const parentPath = this.find(parent);
@@ -1185,6 +1183,7 @@ class PathNode extends ReferenceCountedBase implements AnchorNode {
 		assert(this.status !== Status.Disposed, 0x41d /* PathNode must not be disposed */);
 		if (this.isUnreferenced() && this.children.size === 0 && !this.events.hasListeners()) {
 			if (this.status === Status.Alive) {
+				// eslint-disable-next-line unicorn/prefer-dom-node-remove -- Custom tree structure, not DOM
 				this.parentPath?.removeChild(this);
 			}
 			this.status = Status.Disposed;

package/src/core/tree/detachedFieldIndex.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 import {
@@ -35,7 +35,7 @@ import type {
 	Major,
 	Minor,
 } from "./detachedFieldIndexTypes.js";
-import { makeDetachedFieldIndexCodec } from "./detachedFieldIndexCodecs.js";
+import { detachedFieldIndexCodecBuilder } from "./detachedFieldIndexCodecs.js";
 
 /**
  * Readonly interface for {@link DetachedFieldIndex}.
@@ -52,12 +52,6 @@ export interface ReadOnlyDetachedFieldIndex {
 	 */
 	toFieldKey(id: ForestRootId): FieldKey;
 
-	/**
-	 * Returns a node ID for the node in the given field.
-	 * @param field - The field key where the detached node resides.
-	 */
-	fromFieldKey(field: FieldKey): Delta.DetachedNodeId;
-
 	/**
 	 * Returns the `ForestRootId` associated with the given id.
 	 * Returns undefined if no such id is known to the index.
@@ -126,7 +120,11 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 			jsonValidator: FormatValidatorNoOp,
 			minVersionForCollab: FluidClientVersion.v2_0,
 		};
-		this.codec = makeDetachedFieldIndexCodec(revisionTagCodec, this.options, idCompressor);
+		this.codec = detachedFieldIndexCodecBuilder.build({
+			...this.options,
+			revisionTagCodec,
+			idCompressor,
+		});
 	}
 
 	public clone(): DetachedFieldIndex {
@@ -171,17 +169,17 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 		id: Delta.DetachedNodeId;
 	}> {
 		for (const [major, innerMap] of this.detachedNodeToField) {
-			if (major !== undefined) {
+			if (major === undefined) {
 				for (const [minor, { root, latestRelevantRevision }] of innerMap) {
-					yield latestRelevantRevision !== undefined
-						? { id: { major, minor }, root, latestRelevantRevision }
-						: { id: { major, minor }, root };
+					yield latestRelevantRevision === undefined
+						? { id: { minor }, root }
+						: { id: { minor }, root, latestRelevantRevision };
 				}
 			} else {
 				for (const [minor, { root, latestRelevantRevision }] of innerMap) {
-					yield latestRelevantRevision !== undefined
-						? { id: { minor }, root, latestRelevantRevision }
-						: { id: { minor }, root };
+					yield latestRelevantRevision === undefined
+						? { id: { major, minor }, root }
+						: { id: { major, minor }, root, latestRelevantRevision };
 				}
 			}
 		}
@@ -195,85 +193,10 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 		this.latestRelevantRevisionToFields.clear();
 	}
 
-	public updateMajor(current: Major, updated: Major): void {
-		// Update latestRelevantRevision information corresponding to `current`
-		{
-			const inner = this.latestRelevantRevisionToFields.get(current);
-			if (inner !== undefined) {
-				for (const nodeId of inner.values()) {
-					const entry = tryGetFromNestedMap(
-						this.detachedNodeToField,
-						nodeId.major,
-						nodeId.minor,
-					);
-					assert(
-						entry !== undefined,
-						0x9b8 /* Inconsistent data: missing detached node entry */,
-					);
-					setInNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor, {
-						...entry,
-						latestRelevantRevision: updated,
-					});
-				}
-				this.latestRelevantRevisionToFields.delete(current);
-
-				const updatedInner = this.latestRelevantRevisionToFields.get(updated);
-				if (updatedInner !== undefined) {
-					for (const [root, nodeId] of inner) {
-						updatedInner.set(root, nodeId);
-					}
-				} else {
-					this.latestRelevantRevisionToFields.set(updated, inner);
-				}
-			}
-		}
-
-		// Update the major keys corresponding to `current`
-		{
-			const innerCurrent = this.detachedNodeToField.get(current);
-			if (innerCurrent !== undefined) {
-				this.detachedNodeToField.delete(current);
-				const innerUpdated = this.detachedNodeToField.get(updated);
-				if (innerUpdated === undefined) {
-					this.detachedNodeToField.set(updated, innerCurrent);
-				} else {
-					for (const [minor, entry] of innerCurrent) {
-						assert(
-							innerUpdated.get(minor) === undefined,
-							0x7a9 /* Collision during index update */,
-						);
-						innerUpdated.set(minor, entry);
-					}
-				}
-
-				for (const [minor, entry] of innerCurrent) {
-					const entryInLatest = this.latestRelevantRevisionToFields.get(
-						entry.latestRelevantRevision,
-					);
-					assert(
-						entryInLatest !== undefined,
-						0x9b9 /* Inconsistent data: missing node entry in latestRelevantRevision */,
-					);
-					entryInLatest.set(entry.root, { major: updated, minor });
-				}
-			}
-		}
-	}
-
 	public toFieldKey(id: ForestRootId): FieldKey {
 		return brand(`${this.name}-${id}`);
 	}
 
-	public fromFieldKey(field: FieldKey): Delta.DetachedNodeId {
-		// TODO: maintain a lookup table or use field keys that encode the detached node ID
-		for (const { id, root } of this.entries()) {
-			if (this.toFieldKey(root) === field) {
-				return id;
-			}
-		}
-		fail("No known detached roots in the given field");
-	}
-
 	public tryGetEntry(id: Delta.DetachedNodeId): ForestRootId | undefined {
 		return tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor)?.root;
 	}

package/src/core/tree/detachedFieldIndexCodecCommon.ts

@@ -3,11 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import {
-	type ICodecOptions,
-	type IJsonCodec,
-	makeVersionedValidatedCodec,
-} from "../../codec/index.js";
+import type { IJsonCodec } from "../../codec/index.js";
 import { hasSingle } from "../../util/index.js";
 
 import {
@@ -30,13 +26,13 @@ export function makeDetachedFieldIndexCodecFromMajorCodec<
 	TEncodedRevisionTagSchema extends TSchema,
 	TVersion extends DetachedFieldIndexFormatVersion,
 >(
-	options: ICodecOptions,
 	majorCodec: IJsonCodec<Major, TEncodedRevisionTag>,
 	version: TVersion,
 	encodedRevisionTagSchema: TEncodedRevisionTagSchema,
 ) {
 	const formatSchema = Format(version, encodedRevisionTagSchema);
-	return makeVersionedValidatedCodec(options, new Set([version]), formatSchema, {
+	return {
+		schema: formatSchema,
 		encode: (data: DetachedFieldSummaryData): Static<typeof formatSchema> => {
 			const rootsForRevisions: EncodedRootsForRevision[] = [];
 			for (const [major, innerMap] of data.data) {
@@ -84,5 +80,5 @@ export function makeDetachedFieldIndexCodecFromMajorCodec<
 				maxId: parsed.maxId,
 			};
 		},
-	});
+	};
 }

package/src/core/tree/detachedFieldIndexCodecV1.ts

@@ -6,7 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import type { CodecAndSchema, IJsonCodec } from "../../codec/index.js";
 import {
 	type EncodedRevisionTag,
 	type RevisionTagCodec,
@@ -14,7 +14,6 @@ import {
 	RevisionTagSchema,
 } from "../rebase/index.js";
 
-import type { FormatV1 } from "./detachedFieldIndexFormatV1.js";
 import type { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
 import { makeDetachedFieldIndexCodecFromMajorCodec } from "./detachedFieldIndexCodecCommon.js";
 import { DetachedFieldIndexFormatVersion } from "./detachedFieldIndexFormatCommon.js";
@@ -23,7 +22,6 @@ import { brand } from "../../util/index.js";
 class MajorCodec implements IJsonCodec<Major, EncodedRevisionTag> {
 	public constructor(
 		private readonly revisionTagCodec: RevisionTagCodec,
-		private readonly options: ICodecOptions,
 		private readonly idCompressor: IIdCompressor,
 	) {}
 
@@ -69,12 +67,10 @@ class MajorCodec implements IJsonCodec<Major, EncodedRevisionTag> {
 
 export function makeDetachedNodeToFieldCodecV1(
 	revisionTagCodec: RevisionTagCodec,
-	options: ICodecOptions,
 	idCompressor: IIdCompressor,
-): IJsonCodec<DetachedFieldSummaryData, FormatV1> {
-	const majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);
+): CodecAndSchema<DetachedFieldSummaryData> {
+	const majorCodec = new MajorCodec(revisionTagCodec, idCompressor);
 	return makeDetachedFieldIndexCodecFromMajorCodec(
-		options,
 		majorCodec,
 		brand(DetachedFieldIndexFormatVersion.v1),
 		RevisionTagSchema,