@fluid-experimental/tree 0.58.2001 → 0.59.2000-61729

package/dist/persisted-types/0.1.1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"0.1.1.js","sourceRoot":"","sources":["../../src/persisted-types/0.1.1.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,sCAAyE;AAmBzE,oCAuBiB;AAkIjB;;GAEG;AACU,QAAA,aAAa,GAAG,GAAG,CAAC;AAqFjC,uGAAuG;AACvG;;GAEG;AACU,QAAA,cAAc,GAAG;IAC7B,KAAK,EAAE,CAAC,MAA2C,EAAE,WAA+B,EAAiB,EAAE,CAAC,CAAC;QACxG,WAAW;QACX,MAAM;QACN,IAAI,EAAE,2BAAkB,CAAC,KAAK;KAC9B,CAAC;IAEF,MAAM,EAAE,CAAC,MAA0B,EAAE,WAAgC,EAAkB,EAAE,CAAC,CAAC;QAC1F,WAAW;QACX,MAAM;QACN,IAAI,EAAE,2BAAkB,CAAC,MAAM;KAC/B,CAAC;IAEF,MAAM,EAAE,CAAC,MAA2B,EAAE,WAAgC,EAAkB,EAAE,CAAC,CAAC;QAC3F,WAAW;QACX,MAAM;QACN,IAAI,EAAE,2BAAkB,CAAC,MAAM;KAC/B,CAAC;IAEF,UAAU,EAAE,CAAC,YAAuC,EAAE,OAAgB,EAAoB,EAAE,CAAC,CAAC;QAC7F,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC;QACrC,OAAO;QACP,IAAI,EAAE,2BAAkB,CAAC,QAAQ;KACjC,CAAC;IAEF,YAAY,EAAE,CAAC,YAAuC,EAAoB,EAAE,CAAC,CAAC;QAC7E,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC;QACrC,sFAAsF;QACtF,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,2BAAkB,CAAC,QAAQ;KACjC,CAAC;IAEF,UAAU,EAAE,CACX,WAAgC,EAChC,MAAwB,EACxB,YAAyB,EACzB,MAAe,EACf,WAAwB,EACxB,UAAmB,EACnB,KAAkB,EACG,EAAE,CAAC,CAAC;QACzB,WAAW;QACX,MAAM;QACN,YAAY;QACZ,MAAM;QACN,WAAW;QACX,UAAU;QACV,KAAK;QACL,IAAI,EAAE,2BAAkB,CAAC,UAAU;KACnC,CAAC;IAEF,8CAA8C;IAC9C,MAAM,EAAE,CAAC,WAAgC,EAAkB,EAAE,CAAC,sBAAc,CAAC,MAAM,CAAC,WAAW,CAAC;IAEhG,kDAAkD;IAClD,UAAU,EAAE,CAAC,KAA0C,EAAE,WAAgC,EAAoB,EAAE;QAC9G,MAAM,KAAK,GAAG,sBAAc,CAAC,KAAK,CAAC,KAAK,EAAE,CAAuB,CAAC,CAAC;QACnE,OAAO,CAAC,KAAK,EAAE,sBAAc,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,4CAA4C;IAC5C,IAAI,EAAE,CAAC,MAA2B,EAAE,WAAgC,EAAoB,EAAE;QACzF,MAAM,MAAM,GAAG,sBAAc,CAAC,MAAM,CAAC,MAAM,EAAE,CAAuB,CAAC,CAAC;QACtE,OAAO,CAAC,MAAM,EAAE,sBAAc,CAAC,MAAM,CAAC,2BAAkB,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IAC7F,CAAC;CACD,CAAC;AA6BF;;;GAGG;AAEH;;GAEG;AACU,QAAA,mBAAmB,GAAG;IAClC;;OAEG;IACH,MAAM,EAAE,CAAC,IAA+B,EAAuB,EAAE,CAAC,CAAC;QAClE,IAAI,EAAE,aAAI,CAAC,MAAM;QACjB,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC;KACjC,CAAC;IACF;;OAEG;IACH,KAAK,EAAE,CAAC,IAA+B,EAAuB,EAAE,CAAC,CAAC;QACjE,IAAI,EAAE,aAAI,CAAC,KAAK;QAChB,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC;KACjC,CAAC;IACF;;OAEG;IACH,SAAS,EAAE,CAAC,KAA4B,EAAuB,EAAE,CAAC,CAAC;QAClE,IAAI,EAAE,aAAI,CAAC,KAAK;QAChB,cAAc,EAAE,KAAK;KACrB,CAAC;IACF;;OAEG;IACH,OAAO,EAAE,CAAC,KAA4B,EAAuB,EAAE,CAAC,CAAC;QAChE,IAAI,EAAE,aAAI,CAAC,MAAM;QACjB,cAAc,EAAE,KAAK;KACrB,CAAC;CACF,CAAC;AAEF;;GAEG;AACU,QAAA,mBAAmB,GAAG;IAClC;;;;OAIG;IACH,IAAI,EAAE,CAAC,KAA0B,EAA6D,EAAE,CAAC,CAAC;QACjG,EAAE,EAAE,CAAC,GAAwB,EAAuB,EAAE;YACrD,IAAI,KAAK,CAAC,cAAc,IAAI,GAAG,CAAC,cAAc,EAAE;gBAC/C,MAAM,OAAO,GAAG,oEAAoE,CAAC;gBACrF,eAAM,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,KAAK,GAAG,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAC3E,eAAM,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,KAAK,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;aACzE;YACD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QACvB,CAAC;KACD,CAAC;IACF;;;OAGG;IACH,IAAI,EAAE,CAAC,IAA+B,EAAuB,EAAE,CAAC,CAAC;QAChE,KAAK,EAAE,2BAAmB,CAAC,MAAM,CAAC,IAAI,CAAC;QACvC,GAAG,EAAE,2BAAmB,CAAC,KAAK,CAAC,IAAI,CAAC;KACpC,CAAC;IACF;;;;OAIG;IACH,GAAG,EAAE,CAAC,KAA4B,EAAuB,EAAE,CAAC,CAAC;QAC5D,KAAK,EAAE,2BAAmB,CAAC,SAAS,CAAC,KAAK,CAAC;QAC3C,GAAG,EAAE,2BAAmB,CAAC,OAAO,CAAC,KAAK,CAAC;KACvC,CAAC;CACF,CAAC;AA2BF,sFAAsF;AACtF,+BAA+B;AAClB,QAAA,eAAe,GAAG,EAAE,CAAC;AAElC,2CAA2C;AAC3C,8BAA8B;AACjB,QAAA,cAAc,GAAG,sCAAmD,CAAC;AAElF,+EAA+E;AAC/E,SAAS,SAAS,CAAM,IAAyB;;IAChD,aAAQ,IAAsB,CAAC,UAAU,mCAAK,IAAY,CAAC;AAC5D,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\nimport { assert, assertNotUndefined, ReplaceRecursive } from '../Common';\n// These are re-exported from a persisted-types file.\nimport type {\n\tIdCreationRange,\n\tSerializedIdCompressorWithNoSession,\n\tSerializedIdCompressorWithOngoingSession,\n} from '../id-compressor';\nimport type {\n\tDefinition,\n\tDetachedSequenceId,\n\tEditId,\n\tFinalNodeId,\n\tInternedStringId,\n\tNodeId,\n\tOpSpaceNodeId,\n\tSessionId,\n\tTraitLabel,\n\tUuidString,\n} from '../Identifiers';\nimport {\n\tBuildInternal_0_0_2,\n\tChangeTypeInternal,\n\tConstraintEffect,\n\tConstraintInternal_0_0_2,\n\tDetachInternal_0_0_2,\n\tEdit,\n\tEditWithoutId,\n\tInsertInternal_0_0_2,\n\tNodeData,\n\tPayload,\n\tSetValueInternal_0_0_2,\n\tSharedTreeNoOp,\n\tSharedTreeOpType,\n\tSharedTreeSummaryBase,\n\tSharedTreeUpdateOp,\n\tSide,\n\tStablePlaceInternal_0_0_2,\n\tTraitLocationInternal_0_0_2,\n\tTreeNode,\n\tTreeNodeSequence,\n\tVersionedOp,\n\tWriteFormat,\n} from './0.0.2';\n\n/**\n * Specifies the location of a trait (a labeled sequence of nodes) within the tree.\n * @public\n */\nexport interface TraitLocationInternal extends Omit<TraitLocationInternal_0_0_2, 'parent'> {\n\treadonly parent: NodeId;\n}\n\n/**\n * Alternating list of label then children list under that label.\n * The label may be interned, and children are {@link CompressedPlaceholderTree}.\n */\nexport type CompressedTraits<TId extends OpSpaceNodeId, TPlaceholder extends number | never> = (\n\t| InternedStringId\n\t| TraitLabel\n\t| (CompressedPlaceholderTree<TId, TPlaceholder> | TPlaceholder)[]\n)[];\n\n/**\n * A TreeNode that has been compressed into the following array format:\n * [identifier, definition, traits, payload],\n * where traits is also an array of [label, [trait], label, [trait], ...].\n * Payload is omitted if empty, and traits will be an empty subarray if no traits exist but a payload exists.\n * If both traits and payload does not exist, then both are omitted.\n * All trait labels and node definitions may also be string interned.\n * @internal\n */\nexport type CompressedPlaceholderTree<TId extends OpSpaceNodeId, TPlaceholder extends number | never> =\n\t| TPlaceholder\n\t| [InternedStringId | Definition] // The node Definition's interned string ID\n\t| [InternedStringId | Definition, TId]\n\t| [\n\t\t\tInternedStringId | Definition,\n\t\t\t[Payload, ...CompressedTraits<TId, TPlaceholder>] | CompressedTraits<TId, TPlaceholder>\n\t  ]\n\t| [\n\t\t\tInternedStringId | Definition,\n\t\t\tTId,\n\t\t\t[Payload, ...CompressedTraits<TId, TPlaceholder>] | CompressedTraits<TId, TPlaceholder>\n\t  ];\n\n/**\n * JSON-compatible Node type. Objects of this type will be persisted in internal change objects (under Edits) in the SharedTree history.\n * @public\n */\nexport type ChangeNode = TreeNode<ChangeNode, NodeId>;\n\n/**\n * A ChangeNode that has been compressed into a {@link CompressedPlaceholderTree}.\n */\nexport type CompressedChangeNode<TId extends OpSpaceNodeId> = CompressedPlaceholderTree<TId, never>;\n\n/**\n * The contents of a SharedTree summary for write format 0.1.1.\n * Contains the current tree in a compressed format,\n * the edits needed to get from `initialTree` to the current tree,\n * and the interned strings that can be used to retrieve the interned summary.\n */\nexport interface SharedTreeSummary extends SharedTreeSummaryBase {\n\treadonly version: WriteFormat.v0_1_1;\n\n\treadonly currentTree?: CompressedChangeNode<FinalNodeId>;\n\n\t/**\n\t * Information that can populate an edit log.\n\t */\n\treadonly editHistory: EditLogSummary<CompressedChangeInternal<FinalNodeId>, FluidEditHandle>;\n\n\t/**\n\t * List of interned strings.\n\t * In 0.1.1, definitions and trait labels are interned deterministically on sequenced ops,\n\t * and each client maintains a string interner whose lifetime is tied to the SharedTree.\n\t */\n\treadonly internedStrings: readonly string[];\n\n\t/**\n\t * Information about all IDs compressed in the summary\n\t */\n\treadonly idCompressor: SerializedIdCompressorWithNoSession | SerializedIdCompressorWithOngoingSession;\n}\n\n/**\n * Information used to populate an edit log.\n * In 0.1.1, this is a persisted type only for `EditLogSummary<CompressedChangeInternal, FluidEditHandle>`,\n * where calling `FluidEditHandle.get` returns an array buffer of compressed `editChunk` contents.\n * The type is parameterized to avoid nearly identical type definitions for uncompressed forms of the edit\n * log, and abstracting away the fact that handle fetching needs to invoke decompression.\n * @public\n */\nexport interface EditLogSummary<TChange, THandle> {\n\t/**\n\t * A of list of serialized chunks and their corresponding keys.\n\t * Start revision is the index of the first edit in the chunk in relation to the edit log.\n\t */\n\treadonly editChunks: readonly {\n\t\treadonly startRevision: number;\n\t\t/**\n\t\t * Either a chunk of edits or a handle that can be used to load that chunk.\n\t\t */\n\t\treadonly chunk: THandle | readonly EditWithoutId<TChange>[];\n\t}[];\n\n\t/**\n\t * A list of edits IDs for all sequenced edits.\n\t */\n\treadonly editIds: readonly EditId[];\n}\n\n/**\n * FluidEditHandles are used to load edit chunks stored outside of the EditLog.\n * Can be satisfied by IFluidHandle<ArrayBufferLike>.\n * Note that though this is in `PersistedTypes`, it isn't directly serializable (e.g. `get` is a function).\n * Its serialization relies on being encoded via an IFluidSerializer.\n * @public\n */\nexport interface FluidEditHandle {\n\treadonly get: () => Promise<ArrayBuffer>;\n\treadonly absolutePath: string;\n}\n\n// Future write formats should make this a union type and append to it (e.g. `EditChunkContents_0_1_1 | EditChunkContents_2_0_0`).\nexport type EditChunkContents = EditChunkContents_0_1_1;\n\nexport interface EditChunkContents_0_1_1 {\n\tversion: WriteFormat.v0_1_1;\n\tedits: readonly EditWithoutId<CompressedChangeInternal<FinalNodeId>>[];\n}\n\n/**\n * Edits per edit chunk. This value is in persisted types because it requires consensus to change.\n */\nexport const editsPerChunk = 100;\n\n/**\n * Compressed change format type.\n * Encodes the same information as a {@link ChangeInternal}, but uses a more compact object format for `build` changes.\n */\nexport type CompressedChangeInternal<TId extends OpSpaceNodeId> =\n\t| ReplaceRecursive<Exclude<ChangeInternal, BuildInternal>, NodeId, TId>\n\t| CompressedBuildInternal<TId>;\n\n/**\n * A compressed version of {@link BuildInternal} where the source is a sequence of compressed nodes.\n */\nexport interface CompressedBuildInternal<TId extends OpSpaceNodeId> {\n\t/** {@inheritdoc Build.destination } */\n\treadonly destination: DetachedSequenceId;\n\t/** A sequence of nodes to build in some compressed format. */\n\treadonly source: TreeNodeSequence<CompressedBuildNode<TId>>;\n\t/** {@inheritdoc Build.\"type\" } */\n\treadonly type: typeof ChangeTypeInternal.CompressedBuild;\n}\n\n/**\n * A BuildNode that has been compressed into a {@link CompressedPlaceholderTree}.\n */\nexport type CompressedBuildNode<TId extends OpSpaceNodeId> = CompressedPlaceholderTree<TId, DetachedSequenceId>;\n\n/**\n * {@inheritdoc (Change:type)}\n * @public\n */\nexport type ChangeInternal = InsertInternal | DetachInternal | BuildInternal | SetValueInternal | ConstraintInternal;\n\n/**\n * {@inheritdoc BuildNode}\n * @public\n */\nexport type BuildNodeInternal = TreeNode<BuildNodeInternal, NodeId> | DetachedSequenceId;\n\n/**\n * {@inheritdoc Build}\n * @public\n */\nexport interface BuildInternal extends Omit<BuildInternal_0_0_2, 'source'> {\n\treadonly source: TreeNodeSequence<BuildNodeInternal>;\n}\n\n/**\n * {@inheritdoc (Insert:interface)}\n * @public\n */\nexport interface InsertInternal extends Omit<InsertInternal_0_0_2, 'destination'> {\n\t/** {@inheritdoc (Insert:interface).destination } */\n\treadonly destination: StablePlaceInternal;\n}\n\n/**\n * {@inheritdoc Detach}\n * @public\n */\nexport interface DetachInternal extends Omit<DetachInternal_0_0_2, 'source'> {\n\t/** {@inheritdoc Detach.source } */\n\treadonly source: StableRangeInternal;\n}\n\n/**\n * {@inheritdoc SetValue}\n * @public\n */\nexport interface SetValueInternal extends Omit<SetValueInternal_0_0_2, 'nodeToModify'> {\n\t/** {@inheritdoc SetValue.nodeToModify } */\n\treadonly nodeToModify: NodeId;\n}\n\n/**\n * {@inheritdoc Constraint}\n * @public\n */\nexport interface ConstraintInternal extends Omit<ConstraintInternal_0_0_2, 'toConstrain' | 'parentNode'> {\n\t/** {@inheritdoc Constraint.toConstrain } */\n\treadonly toConstrain: StableRangeInternal;\n\t/** {@inheritdoc Constraint.parentNode } */\n\treadonly parentNode?: NodeId;\n}\n\n// Note: Documentation of this constant is merged with documentation of the `ChangeInternal` interface.\n/**\n * @public\n */\nexport const ChangeInternal = {\n\tbuild: (source: TreeNodeSequence<BuildNodeInternal>, destination: DetachedSequenceId): BuildInternal => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeTypeInternal.Build,\n\t}),\n\n\tinsert: (source: DetachedSequenceId, destination: StablePlaceInternal): InsertInternal => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeTypeInternal.Insert,\n\t}),\n\n\tdetach: (source: StableRangeInternal, destination?: DetachedSequenceId): DetachInternal => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeTypeInternal.Detach,\n\t}),\n\n\tsetPayload: (nodeToModify: NodeData<NodeId> | NodeId, payload: Payload): SetValueInternal => ({\n\t\tnodeToModify: getNodeId(nodeToModify),\n\t\tpayload,\n\t\ttype: ChangeTypeInternal.SetValue,\n\t}),\n\n\tclearPayload: (nodeToModify: NodeData<NodeId> | NodeId): SetValueInternal => ({\n\t\tnodeToModify: getNodeId(nodeToModify),\n\t\t// Rationale: 'undefined' is reserved for future use (see 'SetValue' interface above.)\n\t\tpayload: null,\n\t\ttype: ChangeTypeInternal.SetValue,\n\t}),\n\n\tconstraint: (\n\t\ttoConstrain: StableRangeInternal,\n\t\teffect: ConstraintEffect,\n\t\tidentityHash?: UuidString,\n\t\tlength?: number,\n\t\tcontentHash?: UuidString,\n\t\tparentNode?: NodeId,\n\t\tlabel?: TraitLabel\n\t): ConstraintInternal => ({\n\t\ttoConstrain,\n\t\teffect,\n\t\tidentityHash,\n\t\tlength,\n\t\tcontentHash,\n\t\tparentNode,\n\t\tlabel,\n\t\ttype: ChangeTypeInternal.Constraint,\n\t}),\n\n\t/** {@inheritdoc (Change:variable).delete } */\n\tdelete: (stableRange: StableRangeInternal): ChangeInternal => ChangeInternal.detach(stableRange),\n\n\t/** {@inheritdoc (Change:variable).insertTree } */\n\tinsertTree: (nodes: TreeNodeSequence<BuildNodeInternal>, destination: StablePlaceInternal): ChangeInternal[] => {\n\t\tconst build = ChangeInternal.build(nodes, 0 as DetachedSequenceId);\n\t\treturn [build, ChangeInternal.insert(build.destination, destination)];\n\t},\n\n\t/** {@inheritdoc (Change:variable).move } */\n\tmove: (source: StableRangeInternal, destination: StablePlaceInternal): ChangeInternal[] => {\n\t\tconst detach = ChangeInternal.detach(source, 0 as DetachedSequenceId);\n\t\treturn [detach, ChangeInternal.insert(assertNotUndefined(detach.destination), destination)];\n\t},\n};\n\n/**\n * {@inheritdoc (StablePlace:interface) }\n * @public\n */\nexport interface StablePlaceInternal extends Omit<StablePlaceInternal_0_0_2, 'referenceSibling' | 'referenceTrait'> {\n\t/**\n\t * {@inheritdoc (StablePlace:interface).referenceSibling }\n\t */\n\treadonly referenceSibling?: NodeId;\n\n\t/**\n\t * {@inheritdoc (StablePlace:interface).referenceTrait }\n\t */\n\treadonly referenceTrait?: TraitLocationInternal;\n}\n\n/**\n * {@inheritdoc (StableRange:interface) }\n * @public\n */\nexport interface StableRangeInternal {\n\t/** {@inheritdoc (StableRange:interface).start } */\n\treadonly start: StablePlaceInternal;\n\t/** {@inheritdoc (StableRange:interface).end } */\n\treadonly end: StablePlaceInternal;\n}\n\n/**\n * The remainder of this file consists of factory methods duplicated with those for StableRange/StablePlace and are maintained while\n * the new persisted version of SharedTree ops/summaries is rolled out.\n */\n\n/**\n * @public\n */\nexport const StablePlaceInternal = {\n\t/**\n\t * @returns The location directly before `node`.\n\t */\n\tbefore: (node: NodeData<NodeId> | NodeId): StablePlaceInternal => ({\n\t\tside: Side.Before,\n\t\treferenceSibling: getNodeId(node),\n\t}),\n\t/**\n\t * @returns The location directly after `node`.\n\t */\n\tafter: (node: NodeData<NodeId> | NodeId): StablePlaceInternal => ({\n\t\tside: Side.After,\n\t\treferenceSibling: getNodeId(node),\n\t}),\n\t/**\n\t * @returns The location at the start of `trait`.\n\t */\n\tatStartOf: (trait: TraitLocationInternal): StablePlaceInternal => ({\n\t\tside: Side.After,\n\t\treferenceTrait: trait,\n\t}),\n\t/**\n\t * @returns The location at the end of `trait`.\n\t */\n\tatEndOf: (trait: TraitLocationInternal): StablePlaceInternal => ({\n\t\tside: Side.Before,\n\t\treferenceTrait: trait,\n\t}),\n};\n\n/**\n * @public\n */\nexport const StableRangeInternal = {\n\t/**\n\t * Factory for producing a `StableRange` from a start `StablePlace` to an end `StablePlace`.\n\t * @example\n\t * StableRange.from(StablePlace.before(startNode)).to(StablePlace.after(endNode))\n\t */\n\tfrom: (start: StablePlaceInternal): { to: (end: StablePlaceInternal) => StableRangeInternal } => ({\n\t\tto: (end: StablePlaceInternal): StableRangeInternal => {\n\t\t\tif (start.referenceTrait && end.referenceTrait) {\n\t\t\t\tconst message = 'StableRange must be constructed with endpoints from the same trait';\n\t\t\t\tassert(start.referenceTrait.parent === end.referenceTrait.parent, message);\n\t\t\t\tassert(start.referenceTrait.label === end.referenceTrait.label, message);\n\t\t\t}\n\t\t\treturn { start, end };\n\t\t},\n\t}),\n\t/**\n\t * @returns a `StableRange` which contains only the provided `node`.\n\t * Both the start and end `StablePlace` objects used to anchor this `StableRange` are in terms of the passed in node.\n\t */\n\tonly: (node: NodeData<NodeId> | NodeId): StableRangeInternal => ({\n\t\tstart: StablePlaceInternal.before(node),\n\t\tend: StablePlaceInternal.after(node),\n\t}),\n\t/**\n\t * @returns a `StableRange` which contains everything in the trait.\n\t * This is anchored using the provided `trait`, and is independent of the actual contents of the trait:\n\t * it does not use sibling anchoring.\n\t */\n\tall: (trait: TraitLocationInternal): StableRangeInternal => ({\n\t\tstart: StablePlaceInternal.atStartOf(trait),\n\t\tend: StablePlaceInternal.atEndOf(trait),\n\t}),\n};\n\n/**\n * Discriminated union of valid 0.0.1 SharedTree op types.\n */\nexport type SharedTreeOp = SharedTreeEditOp | SharedTreeHandleOp | SharedTreeUpdateOp | SharedTreeNoOp;\n\nexport interface SharedTreeEditOp extends VersionedOp<WriteFormat.v0_1_1> {\n\treadonly type: SharedTreeOpType.Edit;\n\t/** The collection of changes to apply. */\n\treadonly edit: Edit<CompressedChangeInternal<OpSpaceNodeId>>;\n\t/** Contains all the IDs generated by the originating client since the last sent op */\n\treadonly idRange: IdCreationRange;\n}\n\n/**\n * A SharedTree op that includes edit handle information.\n * The handle corresponds to an edit chunk in the edit log.\n */\nexport interface SharedTreeHandleOp extends VersionedOp<WriteFormat.v0_1_1> {\n\treadonly type: SharedTreeOpType.Handle;\n\t/** The serialized handle to an uploaded edit chunk. */\n\treadonly editHandle: string;\n\t/** The index of the first edit in the chunk that corresponds to the handle. */\n\treadonly startRevision: number;\n}\n\n/** The number of IDs that a SharedTree reserves for current or future internal use */\n// This value must never change\nexport const reservedIdCount = 10;\n\n/** The SessionID of the Upgrade Session */\n// This UUID must never change\nexport const ghostSessionId = '79590933-1c70-4fda-817a-adab57c20318' as SessionId;\n\n/** Accepts either a node or a node's identifier, and returns the identifier */\nfunction getNodeId<TId>(node: TId | NodeData<TId>): TId {\n\treturn (node as NodeData<TId>).identifier ?? (node as TId);\n}\n"]}

package/dist/persisted-types/index.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export * from './0.0.2';
+export * from './0.1.1';
+//# sourceMappingURL=index.d.ts.map

package/dist/persisted-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persisted-types/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/persisted-types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// API Exports
+__exportStar(require("./0.0.2"), exports);
+__exportStar(require("./0.1.1"), exports);
+//# sourceMappingURL=index.js.map

package/dist/persisted-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/persisted-types/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;AAEH,cAAc;AAEd,0CAAwB;AACxB,0CAAwB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// API Exports\n\nexport * from './0.0.2';\nexport * from './0.1.1';\n"]}

package/docs/0-1-1-Compression.md

@@ -0,0 +1,228 @@
+# 0.1.1 Compression
+
+The 0.1.1 format brings a number of improvements to how we encode edit information in ops and summaries.
+To reduce bloat in common property names, we use the following union type of arrays to represent a tree:
+
+```typescript
+export type CompressedTraits<TId extends OpSpaceNodeId, TPlaceholder extends number | never> = (
+	| InternedStringId
+	| TraitLabel
+	| (CompressedPlaceholderTree<TId, TPlaceholder> | TPlaceholder)[]
+)[];
+
+export type CompressedPlaceholderTree<TId extends OpSpaceNodeId, TPlaceholder extends number | never> =
+	| TPlaceholder
+	| [InternedStringId | Definition] // The node Definition's interned string ID
+	| [InternedStringId | Definition, TId]
+	| [
+			InternedStringId | Definition,
+			[Payload, ...CompressedTraits<TId, TPlaceholder>] | CompressedTraits<TId, TPlaceholder>
+	  ]
+	| [InternedStringId, TId, [Payload, ...CompressedTraits<TId, TPlaceholder>] | CompressedTraits<TId, TPlaceholder>];
+```
+
+This type incorporates 4 major compression optimizations:
+
+1. Structural compression
+2. Definition/trait label interning
+3. Identifier compression
+4. Sequential identifier elision
+
+These optimizations will be presented sequentially, starting from the same initial tree (the "test tree" used in many shared-tree tests).
+
+## Structural compression
+
+Conceptually, we pack the object types more densely into an array to avoid long property names such as "definition" and "identifier" being repeated.
+The particular format we use is an array whose first element is the definition, the second element is the identifier (if not elided--see [Identifier Elision](#identifier-elision)), and whose last element is a compressed traits/payload object.
+A compressed set of traits is an alternating array of trait labels and trait contents.
+When the payload is present, it is inserted as the first element of the array.
+This allows detection of if a node has a payload using the parity of the length of the array.
+
+For example, this 0.0.2 summary:
+
+```json
+{
+	"currentTree": {
+		"definition": "51c58718-47b9-4fe4-ad46-56312f3b9e86",
+		"identifier": "24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6",
+		"traits": {
+			"e276f382-fa99-49a1-ae81-42001791c733": [
+				{
+					"definition": "node",
+					"identifier": "25de3875-9537-47ec-8699-8a85e772a509",
+					"traits": {
+						"left": [
+							{
+								"definition": "node",
+								"identifier": "ae6b24eb-6fa8-42cc-abd2-48f250b7798f",
+								"payload": 248,
+								"traits": {}
+							},
+							{ "definition": "node", "identifier": "a083857d-a8e1-447a-ba7c-92fd0be9db2b", "traits": {} }
+						],
+						"right": [
+							{ "definition": "node", "identifier": "78849e85-cb7f-4b93-9fdc-18439c60fe30", "traits": {} }
+						]
+					}
+				}
+			]
+		}
+	}
+}
+```
+
+would be structurally compressed to:
+
+```json
+{
+	"currentTree": [
+		"51c58718-47b9-4fe4-ad46-56312f3b9e86",
+		"24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6",
+		[
+			"e276f382-fa99-49a1-ae81-42001791c733",
+			[
+				[
+					"node",
+					"25de3875-9537-47ec-8699-8a85e772a509",
+					[
+						"left",
+						[
+							["node", "ae6b24eb-6fa8-42cc-abd2-48f250b7798f", [248]],
+							["node", "a083857d-a8e1-447a-ba7c-92fd0be9db2b"]
+						],
+						"right",
+						[["node", "78849e85-cb7f-4b93-9fdc-18439c60fe30"]]
+					]
+				]
+			]
+		]
+	]
+}
+```
+
+## Definition and Trait Label interning
+
+Typical `SharedTree` users will likely have a relatively small common set of definitions and trait labels used for actual content, often conforming to some schema.
+We can leverage this fact by interning the strings and storing references to them in trees.
+This interning can be associated with each document by storing a list of interned strings in the summary and ensuring all clients agree on which order to sequence newly used definitions/identifiers.
+Interning such values on each sequenced op in a consistent tree walk order suffices to achieve such consensus.
+
+Applying this on top of the previous optimization would yield a summary resembling the following:
+
+```json
+{
+	"currentTree": [
+		0,
+		"24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6",
+		[
+			1,
+			[
+				[
+					2,
+					"25de3875-9537-47ec-8699-8a85e772a509",
+					[
+						3,
+						[
+							[2, "ae6b24eb-6fa8-42cc-abd2-48f250b7798f", [248]],
+							[2, "a083857d-a8e1-447a-ba7c-92fd0be9db2b"]
+						],
+						4,
+						[[2, "78849e85-cb7f-4b93-9fdc-18439c60fe30"]]
+					]
+				]
+			]
+		]
+	],
+	"internedStrings": [
+		"51c58718-47b9-4fe4-ad46-56312f3b9e86",
+		"e276f382-fa99-49a1-ae81-42001791c733",
+		"node",
+		"left",
+		"right"
+	]
+}
+```
+
+In the future, this strategy also enables the potential for GC of formerly used definitions, though that isn't implemented with the introduction of 0.1.1.
+
+### Identifier Compression
+
+SharedTree uses a strategy for identifier compression outlined in [IdCompressor.ts](../src/id-compressor/IdCompressor.md) which allows identities to be allocated in clusters for each session.
+This enables ops/summaries to be written in terms of smaller numbers (offsets) from those clusters.
+The upgrade/migration strategy from 0.0.2 is not entirely straightforward, but if the specific identifiers used for the summary above are not significant and the same tree were recreated on a 0.1.1 document, its summary could instead resemble the following:
+
+```javascript
+{
+	"currentTree": [
+		0,
+		0,
+		[
+			1,
+			[
+				[
+					2,
+					1,
+					[
+						3,
+						[
+							[2, 2, [248]],
+							[2, 3]
+						],
+						4,
+						[[2, 4]]
+					]
+				]
+			]
+		]
+	],
+	"internedStrings": [
+		"51c58718-47b9-4fe4-ad46-56312f3b9e86",
+		"e276f382-fa99-49a1-ae81-42001791c733",
+		"node",
+		"left",
+		"right"
+	],
+	"idCompressor": { /* some serialized representation of the id compressor; in practice this might symbolize some intent along the lines of "ids 0-4 are offsets from the uuid '24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6'" */ }
+}
+```
+
+### Identifier Elision
+
+In the common case, consumers of `SharedTree` will build a tree without caring what identifier is chosen for each node.
+In this case, the tree will be given identifiers in a depth-first preorder traversal.
+Since there is a canonical order, we can therefore _omit_ identifiers that are the expected next value, only including them on nodes which aren't just the following allocated value.
+Then, on decoding, we track the current "next identifier" and use that if the compressed format doesn't include an override.
+For the above tree, this would be all nodes except for the root.
+
+```javascript
+{
+	"currentTree": [
+		0,
+		[
+			1,
+			[
+				[
+					2,
+					[
+						3,
+						[
+							[2, [248]],
+							[2]
+						],
+						4,
+						[[2]]
+					]
+				]
+			]
+		]
+	],
+	"internedStrings": [
+		"51c58718-47b9-4fe4-ad46-56312f3b9e86",
+		"e276f382-fa99-49a1-ae81-42001791c733",
+		"node",
+		"left",
+		"right"
+	],
+	"idCompressor": { /* some serialized representation of the id compressor; in practice this might symbolize some intent along the lines of "ids 0-4 are offsets from the uuid '24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6'" */ }
+}
+```

package/docs/Breaking-Change-Migration.md

@@ -0,0 +1,52 @@
+# Breaking Change Migration
+
+We describe here the general mechanism by which persisted formats are updated.
+This mechanism allows us to safely make breaking changes to e.g. summaries and ops within ongoing sessions without having to retain any old state in the new version of the ops.
+Persisted contents of `SharedTree` include ops, summaries, and uploaded edit chunks.
+
+The migration mechanism depends on a staged rollout so we can be sure all clients have the new code.
+The staged rollout process is orthogonal and not described here.
+
+Because this mechanism only takes effect for documents which are opened, backwards compatibility for all previously supported formats is still required.
+However, this enables future format optimizations to apply to existing documents, once converted.
+
+## Detecting When an Update is Needed
+
+The version of a `SharedTree` is dictated by its `writeFormat` field.
+When a summary is loaded, `SharedTree` compares the version of the loaded summary with its version.
+If the loaded version is older, it is necessary to update the summary to match the `SharedTree` version.
+
+To prepare for the update, an update op is sent out with the version to update to and the `SharedTree` version is set to the loaded version so that the old format is written until the update op gets sequenced.
+
+The loaded summary is then structurally converted to the latest version before it is used to create the `EditLog`.
+This means that the loaded data is not modified but it may be moved around to fit the structure of the latest format.
+
+## Sequencing an Update Op
+
+When an update op is received, we check to make sure the update is valid and hasn't already been completed due to concurrent upgrade attempts. If so, the update is processed.
+
+To process an update, a summary is first taken in the old format version.
+An upgrade conversion is performed on that summary (including any data modifications that are deemed acceptable) and the resulting summary is then used to recreate objects that `SharedTree` is dependent on to store state including `EditLog`.
+The `SharedTree` processing the update is also expected to resubmit all of its local ops using the new write version, again potentially including any data modifications that are deemed acceptable.
+
+## Versioned Ops
+
+Ops may include a version field; if they do not, it is assumed they have version 0.0.2.
+For ops that are not update ops, this is an indication of whether or not a client should process an op.
+Ops should only be processed by clients that have the same version.
+This prevents clients from processing ops that may have mismatched data if they have not yet been appropriately updated.
+It is expected that at the time a client receives an update op, they re-submit any local ops they have generated which are concurrent to the update op, after reinterpreting those ops to match the new format.
+This strategy empowers the submitting client with the ability to augment those concurrent ops with any metadata required by the new op format.
+Because all of the concurrent ops must be sequenced after the update op,
+they will be ignored by all clients and thus this resubmission is safe.
+
+It is not necessary to store op versions or ignored ops in the history.
+This is because clients will only ever receive ops at the same versions as each other e.g. for edit v1 update v2 edit v1 edit v2, every client must have seen update v2 before seeing the second edit v1 so we know we can safely throw it away without any client deciding to process it instead.
+The version is only needed so that the client knows whether it can process the op or not.
+This isn't necessary to store in history since if it's in the history, we know it was processed correctly by a client with the same version.
+Once the summary is written, any edits in the history are ones that we know were valid.
+And when a summary is updated using this migration mechanism, these old edits are also updated to match the newest version so we won't end up in a situation where we have old edits in the history that can't be processed by the current client.
+However, because of history virtualization, this only applies when async summarization is supported to allow us to download old edits asynchronously and then update them.
+While async summarization is not supported, we are choosing to throw away history when updates to edits are needed.
+
+Update ops are idempotent (meaning updates with the same version as the client are ignored).

package/docs/Compression.md

@@ -1,6 +1,6 @@
 # Compression
 
-This document covers reducing per node costs in common high node count use-cases using the approach prototyped in <https://github.com/CraigMacomber/sequence/tree/main/src>.
+This document covers reducing per node costs in common high node count use-cases using the approach prototyped in <https://github.com/CraigMacomber/sequence/tree/main/forest/src>.
 
 ## Motivation
 
@@ -93,7 +93,7 @@ The `schema` information can be factored into two parts:
     - definition
     - does it have a value? (if using a byte array, how long is the value)
     - list of traits (each with a trait id, a child count, and a reference to a `schema` for the child)
-2. Derived data used to accelerate lookups. This is omitted from the serialized version of UniformChunk, and is not detailed here. The short version is store what ever is needed to optimize the implementation of Chunk that UniformChunk provides. This is only needed on the root schema, and is why (Ex: [RootChunkSchema](https://github.com/CraigMacomber/sequence/blob/main/src/chunk.rs#L24)) is distinct from [ChunkSchema](https://github.com/CraigMacomber/sequence/blob/ada56998a853ea19b5a6536e7b79771400044bc0/src/chunk.rs#L106). Things like tables to look up schema or parent info from `idOffset % stride` (where stride is the number of nodes in the schema for a single tree in the two level sequence) belong there.
+2. Derived data used to accelerate lookups. This is omitted from the serialized version of UniformChunk, and is not detailed here. The short version is store what ever is needed to optimize the implementation of Chunk that UniformChunk provides. This is only needed on the root schema, and is why (Ex: [RootChunkSchema](https://github.com/CraigMacomber/sequence/blob/main/forest/src/chunk.rs#L24)) is distinct from [ChunkSchema](https://github.com/CraigMacomber/sequence/blob/ada56998a853ea19b5a6536e7b79771400044bc0/src/chunk.rs#L106). Things like tables to look up schema or parent info from `idOffset % stride` (where stride is the number of nodes in the schema for a single tree in the two level sequence) belong there.
 
 Another way to think about this is there are 3 classes of data for nodes in a uniform chunk:
 

package/docs/Telemetry.md

@@ -0,0 +1,43 @@
+# SharedTree Telemetry
+
+The following are telemetry events that are logged in the `shared-tree` package and their descriptions:
+
+## BecameOldestClient
+
+The client has become the oldest client in the quorum.
+
+## NoOpSent
+
+A NoOp operation has been sent to add a client to the quorum.
+
+## SummaryCreation
+
+This is a performance event where each `SummaryCreationStart` has a corresponding `SummaryCreationEnd` event that contains additional information, or a `SummaryCreationFailure` event with additional error information.
+
+-   **SummaryCreationStart**: Starting the creation of a new summary.
+-   **SummaryCreationEnd**: Finished creating a new summary. This is a performance event that includes the duration of time it took to complete creating a new summary. Also includes statistics on the summary created which consists of history size, number of chunks, number of uploaded chunks, and format version.
+-   **SummaryCreationFailure**: Creation of a new summary failed.
+
+## SummaryConversion
+
+Converting old summary to new read format version.
+
+## SummaryLoad
+
+This is a performance event where each `SummaryLoadStart` has a corresponding `SummaryLoadEnd` event that contains additional information, or a `SummaryLoadFailure` event with additional error information.
+
+-   **SummaryLoadStart**: Started loading a summary.
+-   **SummaryLoadEnd**: Finished loading a summary. This is a performance event that includes the duration of time it took to complete the summary load. Also includes statistics on the summary loaded which consists of history size, number of chunks, number of uploaded chunks, and format version.
+-   **SummaryLoadFailure**: Failed to load a summary.
+
+## CatchUpBlobUpload
+
+Successfully uploaded a catch up blob.
+
+## EditChunkUpload
+
+Successfully uploaded an edit chunk blob that is not a catch up blob.
+
+## EditChunkUploadFailure
+
+Failed to upload an edit chunk blob.

package/docs/Write-Format.md

@@ -0,0 +1,19 @@
+# SharedTree Write Format
+
+A SharedTree is given a **write format** upon creation. The write format dictates the scheme used to encode ops sent by the DDS as well as its summary format. Future write formats cannot be interpreted by SharedTrees that only understand past write formats and therefore care must be taken when migrating to a new format (e.g. the rollout of a new format must be delayed/staged until all clients support the new write format).
+
+## Document Upgrade
+
+SharedTree will automatically upgrade documents to a newer write format when necessary. This happens when a client with a newer write format loads a document written in an older write format. The joining client will upgrade the document to the new format as well as notify the other clients to change automatically to the newer write format.
+
+> After a document upgrade occurs, clients that do not support the new write format will no longer be able to read the document!
+
+## Write Formats
+
+### 0.0.2
+
+The first released write format. Ops and summaries are not compressed or optimized.
+
+### 0.1.1
+
+An optimized encoding is used for ops and summaries to dramatically reduce their serialized size. See the [0.1.1 compression document](./Compression.md) for details.

package/lib/ChangeCompression.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DetachedSequenceId, OpSpaceNodeId } from './Identifiers';
+import { ChangeInternal, CompressedChangeInternal } from './persisted-types';
+import { ContextualizedNodeIdNormalizer } from './NodeIdUtilities';
+import { TreeCompressor } from './TreeCompressor';
+import { StringInterner } from './StringInterner';
+/**
+ * Encapsulates knowledge of how to compress/decompress a change into a compressed change
+ * Compression and decompression each take in a {@link StringInterner} for deduplicating shared strings.
+ * @internal
+ */
+export declare class ChangeCompressor {
+    private readonly treeCompressor;
+    constructor(treeCompressor: TreeCompressor<DetachedSequenceId>);
+    compress<TId extends OpSpaceNodeId>(change: ChangeInternal, interner: StringInterner, idNormalizer: ContextualizedNodeIdNormalizer<TId>): CompressedChangeInternal<TId>;
+    decompress<TId extends OpSpaceNodeId>(change: CompressedChangeInternal<TId>, interner: StringInterner, idNormalizer: ContextualizedNodeIdNormalizer<TId>): ChangeInternal;
+}
+/**
+ * Compresses the provided edit by applying `compressor` to each change and leaving other fields
+ * untouched.
+ */
+export declare function compressEdit<TId extends OpSpaceNodeId, TEdit extends {
+    changes: readonly ChangeInternal[];
+}>(compressor: ChangeCompressor, interner: StringInterner, idNormalizer: ContextualizedNodeIdNormalizer<TId>, edit: TEdit): Omit<TEdit, 'changes'> & {
+    changes: readonly CompressedChangeInternal<TId>[];
+};
+/**
+ * Decompresses the provided edit by applying `compressor` to each change and leaving other fields
+ * untouched.
+ */
+export declare function decompressEdit<TId extends OpSpaceNodeId, TEdit extends {
+    changes: readonly CompressedChangeInternal<TId>[];
+}>(compressor: ChangeCompressor, interner: StringInterner, idNormalizer: ContextualizedNodeIdNormalizer<TId>, edit: TEdit): Omit<TEdit, 'changes'> & {
+    changes: readonly ChangeInternal[];
+};
+//# sourceMappingURL=ChangeCompression.d.ts.map

package/lib/ChangeCompression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChangeCompression.d.ts","sourceRoot":"","sources":["../src/ChangeCompression.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAU,aAAa,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAGN,cAAc,EACd,wBAAwB,EAQxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;GAIG;AACH,qBAAa,gBAAgB;IACT,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAAd,cAAc,EAAE,cAAc,CAAC,kBAAkB,CAAC;IAE/E,QAAQ,CAAC,GAAG,SAAS,aAAa,EACxC,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,8BAA8B,CAAC,GAAG,CAAC,GAC/C,wBAAwB,CAAC,GAAG,CAAC;IAiBzB,UAAU,CAAC,GAAG,SAAS,aAAa,EAC1C,MAAM,EAAE,wBAAwB,CAAC,GAAG,CAAC,EACrC,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,8BAA8B,CAAC,GAAG,CAAC,GAC/C,cAAc;CAgBjB;AAmDD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,SAAS,aAAa,EAAE,KAAK,SAAS;IAAE,OAAO,EAAE,SAAS,cAAc,EAAE,CAAA;CAAE,EAC3G,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,8BAA8B,CAAC,GAAG,CAAC,EACjD,IAAI,EAAE,KAAK,GACT,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,SAAS,wBAAwB,CAAC,GAAG,CAAC,EAAE,CAAA;CAAE,CAKhF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,GAAG,SAAS,aAAa,EACzB,KAAK,SAAS;IAAE,OAAO,EAAE,SAAS,wBAAwB,CAAC,GAAG,CAAC,EAAE,CAAA;CAAE,EAEnE,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,8BAA8B,CAAC,GAAG,CAAC,EACjD,IAAI,EAAE,KAAK,GACT,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,SAAS,cAAc,EAAE,CAAA;CAAE,CAKjE"}

package/lib/ChangeCompression.js

@@ -0,0 +1,111 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangeTypeInternal, } from './persisted-types';
+import { copyPropertyIfDefined, fail } from './Common';
+import { convertStablePlaceIds, convertStableRangeIds } from './IdConversion';
+/**
+ * Encapsulates knowledge of how to compress/decompress a change into a compressed change
+ * Compression and decompression each take in a {@link StringInterner} for deduplicating shared strings.
+ * @internal
+ */
+export class ChangeCompressor {
+    constructor(treeCompressor) {
+        this.treeCompressor = treeCompressor;
+    }
+    compress(change, interner, idNormalizer) {
+        if (change.type === ChangeTypeInternal.Build) {
+            const source = [];
+            for (const node of change.source) {
+                source.push(this.treeCompressor.compress(node, interner, idNormalizer));
+            }
+            const newChange = {
+                destination: change.destination,
+                source,
+                type: ChangeTypeInternal.CompressedBuild,
+            };
+            return newChange;
+        }
+        else {
+            return normalizeChange(change, (id) => idNormalizer.normalizeToOpSpace(id));
+        }
+    }
+    decompress(change, interner, idNormalizer) {
+        if (change.type === ChangeTypeInternal.CompressedBuild) {
+            const source = [];
+            for (const node of change.source) {
+                source.push(this.treeCompressor.decompress(node, interner, idNormalizer));
+            }
+            const newChange = {
+                destination: change.destination,
+                source,
+                type: ChangeTypeInternal.Build,
+            };
+            return newChange;
+        }
+        else {
+            return normalizeChange(change, (id) => idNormalizer.normalizeToSessionSpace(id));
+        }
+    }
+}
+function normalizeChange(change, normalizeId) {
+    switch (change.type) {
+        case ChangeTypeInternal.Insert: {
+            const insert = {
+                source: change.source,
+                destination: convertStablePlaceIds(change.destination, normalizeId),
+                type: ChangeTypeInternal.Insert,
+            };
+            return insert;
+        }
+        case ChangeTypeInternal.Detach: {
+            const detach = {
+                source: convertStableRangeIds(change.source, normalizeId),
+                type: ChangeTypeInternal.Detach,
+            };
+            copyPropertyIfDefined(change, detach, 'destination');
+            return detach;
+        }
+        case ChangeTypeInternal.SetValue: {
+            const setValue = {
+                nodeToModify: normalizeId(change.nodeToModify),
+                payload: change.payload,
+                type: ChangeTypeInternal.SetValue,
+            };
+            return setValue;
+        }
+        case ChangeTypeInternal.Constraint: {
+            const constraint = {
+                effect: change.effect,
+                toConstrain: convertStableRangeIds(change.toConstrain, normalizeId),
+                type: ChangeTypeInternal.Constraint,
+            };
+            copyPropertyIfDefined(change, constraint, 'contentHash');
+            copyPropertyIfDefined(change, constraint, 'identityHash');
+            copyPropertyIfDefined(change, constraint, 'label');
+            copyPropertyIfDefined(change, constraint, 'length');
+            if (change.parentNode !== undefined) {
+                constraint.parentNode = normalizeId(change.parentNode);
+            }
+            return constraint;
+        }
+        default:
+            fail('unexpected change type');
+    }
+}
+/**
+ * Compresses the provided edit by applying `compressor` to each change and leaving other fields
+ * untouched.
+ */
+export function compressEdit(compressor, interner, idNormalizer, edit) {
+    return Object.assign(Object.assign({}, edit), { changes: edit.changes.map((change) => compressor.compress(change, interner, idNormalizer)) });
+}
+/**
+ * Decompresses the provided edit by applying `compressor` to each change and leaving other fields
+ * untouched.
+ */
+export function decompressEdit(compressor, interner, idNormalizer, edit) {
+    return Object.assign(Object.assign({}, edit), { changes: edit.changes.map((change) => compressor.decompress(change, interner, idNormalizer)) });
+}
+//# sourceMappingURL=ChangeCompression.js.map

package/lib/ChangeCompression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChangeCompression.js","sourceRoot":"","sources":["../src/ChangeCompression.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { DetachedSequenceId, NodeId, OpSpaceNodeId } from './Identifiers';\nimport {\n\tBuildInternal,\n\tBuildNodeInternal,\n\tChangeInternal,\n\tCompressedChangeInternal,\n\tChangeTypeInternal,\n\tCompressedBuildInternal,\n\tCompressedPlaceholderTree,\n\tInsertInternal,\n\tDetachInternal,\n\tSetValueInternal,\n\tConstraintInternal,\n} from './persisted-types';\nimport { ContextualizedNodeIdNormalizer } from './NodeIdUtilities';\nimport { copyPropertyIfDefined, fail, Mutable, ReplaceRecursive } from './Common';\nimport { TreeCompressor } from './TreeCompressor';\nimport { StringInterner } from './StringInterner';\nimport { convertStablePlaceIds, convertStableRangeIds } from './IdConversion';\n\n/**\n * Encapsulates knowledge of how to compress/decompress a change into a compressed change\n * Compression and decompression each take in a {@link StringInterner} for deduplicating shared strings.\n * @internal\n */\nexport class ChangeCompressor {\n\tpublic constructor(private readonly treeCompressor: TreeCompressor<DetachedSequenceId>) {}\n\n\tpublic compress<TId extends OpSpaceNodeId>(\n\t\tchange: ChangeInternal,\n\t\tinterner: StringInterner,\n\t\tidNormalizer: ContextualizedNodeIdNormalizer<TId>\n\t): CompressedChangeInternal<TId> {\n\t\tif (change.type === ChangeTypeInternal.Build) {\n\t\t\tconst source: CompressedPlaceholderTree<TId, DetachedSequenceId>[] = [];\n\t\t\tfor (const node of change.source) {\n\t\t\t\tsource.push(this.treeCompressor.compress(node, interner, idNormalizer));\n\t\t\t}\n\t\t\tconst newChange: CompressedBuildInternal<TId> = {\n\t\t\t\tdestination: change.destination,\n\t\t\t\tsource,\n\t\t\t\ttype: ChangeTypeInternal.CompressedBuild,\n\t\t\t};\n\t\t\treturn newChange;\n\t\t} else {\n\t\t\treturn normalizeChange(change, (id) => idNormalizer.normalizeToOpSpace(id));\n\t\t}\n\t}\n\n\tpublic decompress<TId extends OpSpaceNodeId>(\n\t\tchange: CompressedChangeInternal<TId>,\n\t\tinterner: StringInterner,\n\t\tidNormalizer: ContextualizedNodeIdNormalizer<TId>\n\t): ChangeInternal {\n\t\tif (change.type === ChangeTypeInternal.CompressedBuild) {\n\t\t\tconst source: BuildNodeInternal[] = [];\n\t\t\tfor (const node of change.source) {\n\t\t\t\tsource.push(this.treeCompressor.decompress(node, interner, idNormalizer));\n\t\t\t}\n\t\t\tconst newChange: BuildInternal = {\n\t\t\t\tdestination: change.destination,\n\t\t\t\tsource,\n\t\t\t\ttype: ChangeTypeInternal.Build,\n\t\t\t};\n\t\t\treturn newChange;\n\t\t} else {\n\t\t\treturn normalizeChange(change, (id) => idNormalizer.normalizeToSessionSpace(id));\n\t\t}\n\t}\n}\n\nfunction normalizeChange<From extends NodeId | OpSpaceNodeId, To extends NodeId | OpSpaceNodeId>(\n\tchange: ReplaceRecursive<Exclude<ChangeInternal, BuildInternal>, NodeId, From>,\n\tnormalizeId: (id: From) => To\n): ReplaceRecursive<Exclude<ChangeInternal, BuildInternal>, NodeId, To> {\n\tswitch (change.type) {\n\t\tcase ChangeTypeInternal.Insert: {\n\t\t\tconst insert: ReplaceRecursive<InsertInternal, NodeId, To> = {\n\t\t\t\tsource: change.source,\n\t\t\t\tdestination: convertStablePlaceIds(change.destination, normalizeId),\n\t\t\t\ttype: ChangeTypeInternal.Insert,\n\t\t\t};\n\t\t\treturn insert;\n\t\t}\n\t\tcase ChangeTypeInternal.Detach: {\n\t\t\tconst detach: ReplaceRecursive<DetachInternal, NodeId, To> = {\n\t\t\t\tsource: convertStableRangeIds(change.source, normalizeId),\n\t\t\t\ttype: ChangeTypeInternal.Detach,\n\t\t\t};\n\t\t\tcopyPropertyIfDefined(change, detach, 'destination');\n\t\t\treturn detach;\n\t\t}\n\t\tcase ChangeTypeInternal.SetValue: {\n\t\t\tconst setValue: ReplaceRecursive<SetValueInternal, NodeId, To> = {\n\t\t\t\tnodeToModify: normalizeId(change.nodeToModify),\n\t\t\t\tpayload: change.payload,\n\t\t\t\ttype: ChangeTypeInternal.SetValue,\n\t\t\t};\n\t\t\treturn setValue;\n\t\t}\n\t\tcase ChangeTypeInternal.Constraint: {\n\t\t\tconst constraint: Mutable<ReplaceRecursive<ConstraintInternal, NodeId, To>> = {\n\t\t\t\teffect: change.effect,\n\t\t\t\ttoConstrain: convertStableRangeIds(change.toConstrain, normalizeId),\n\t\t\t\ttype: ChangeTypeInternal.Constraint,\n\t\t\t};\n\t\t\tcopyPropertyIfDefined(change, constraint, 'contentHash');\n\t\t\tcopyPropertyIfDefined(change, constraint, 'identityHash');\n\t\t\tcopyPropertyIfDefined(change, constraint, 'label');\n\t\t\tcopyPropertyIfDefined(change, constraint, 'length');\n\t\t\tif (change.parentNode !== undefined) {\n\t\t\t\tconstraint.parentNode = normalizeId(change.parentNode);\n\t\t\t}\n\t\t\treturn constraint;\n\t\t}\n\t\tdefault:\n\t\t\tfail('unexpected change type');\n\t}\n}\n\n/**\n * Compresses the provided edit by applying `compressor` to each change and leaving other fields\n * untouched.\n */\nexport function compressEdit<TId extends OpSpaceNodeId, TEdit extends { changes: readonly ChangeInternal[] }>(\n\tcompressor: ChangeCompressor,\n\tinterner: StringInterner,\n\tidNormalizer: ContextualizedNodeIdNormalizer<TId>,\n\tedit: TEdit\n): Omit<TEdit, 'changes'> & { changes: readonly CompressedChangeInternal<TId>[] } {\n\treturn {\n\t\t...edit,\n\t\tchanges: edit.changes.map((change) => compressor.compress(change, interner, idNormalizer)),\n\t};\n}\n\n/**\n * Decompresses the provided edit by applying `compressor` to each change and leaving other fields\n * untouched.\n */\nexport function decompressEdit<\n\tTId extends OpSpaceNodeId,\n\tTEdit extends { changes: readonly CompressedChangeInternal<TId>[] }\n>(\n\tcompressor: ChangeCompressor,\n\tinterner: StringInterner,\n\tidNormalizer: ContextualizedNodeIdNormalizer<TId>,\n\tedit: TEdit\n): Omit<TEdit, 'changes'> & { changes: readonly ChangeInternal[] } {\n\treturn {\n\t\t...edit,\n\t\tchanges: edit.changes.map((change) => compressor.decompress(change, interner, idNormalizer)),\n\t};\n}\n"]}