@fluidframework/test-runtime-utils 2.71.0 → 2.73.0

package/dist/index.d.ts

@@ -11,5 +11,5 @@ export { MockHandle } from "./mockHandle.js";
 export { IMockContainerRuntimePendingMessage, MockContainerRuntime, IMockContainerRuntimeOptions, MockContainerRuntimeFactory, MockDeltaConnection, MockEmptyDeltaConnection, MockFluidDataStoreRuntime, MockObjectStorageService, MockQuorumClients, MockAudience, MockSharedObjectServices, IInternalMockRuntimeMessage, } from "./mocks.js";
 export { MockContainerRuntimeFactoryForReconnection, MockContainerRuntimeForReconnection, } from "./mocksForReconnection.js";
 export { MockStorage } from "./mockStorage.js";
-export { validateAssertionError } from "./validateAssertionError.js";
+export { validateAssertionError, validateUsageError, validateTypeError, validateError, } from "./validateAssertionError.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACN,mCAAmC,EACnC,oBAAoB,EACpB,4BAA4B,EAC5B,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EACjB,YAAY,EACZ,wBAAwB,EACxB,2BAA2B,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,0CAA0C,EAC1C,mCAAmC,GACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACN,mCAAmC,EACnC,oBAAoB,EACpB,4BAA4B,EAC5B,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EACjB,YAAY,EACZ,wBAAwB,EACxB,2BAA2B,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,0CAA0C,EAC1C,mCAAmC,GACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACN,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,GACb,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAssertionError = exports.MockStorage = exports.MockContainerRuntimeForReconnection = exports.MockContainerRuntimeFactoryForReconnection = exports.MockSharedObjectServices = exports.MockAudience = exports.MockQuorumClients = exports.MockObjectStorageService = exports.MockFluidDataStoreRuntime = exports.MockEmptyDeltaConnection = exports.MockDeltaConnection = exports.MockContainerRuntimeFactory = exports.MockContainerRuntime = exports.MockHandle = exports.MockDeltaQueue = exports.MockDeltaManager = exports.MockFluidDataStoreContext = exports.InsecureTokenProvider = exports.deepFreeze = void 0;
+exports.validateError = exports.validateTypeError = exports.validateUsageError = exports.validateAssertionError = exports.MockStorage = exports.MockContainerRuntimeForReconnection = exports.MockContainerRuntimeFactoryForReconnection = exports.MockSharedObjectServices = exports.MockAudience = exports.MockQuorumClients = exports.MockObjectStorageService = exports.MockFluidDataStoreRuntime = exports.MockEmptyDeltaConnection = exports.MockDeltaConnection = exports.MockContainerRuntimeFactory = exports.MockContainerRuntime = exports.MockHandle = exports.MockDeltaQueue = exports.MockDeltaManager = exports.MockFluidDataStoreContext = exports.InsecureTokenProvider = exports.deepFreeze = void 0;
 var deepFreeze_js_1 = require("./deepFreeze.js");
 Object.defineProperty(exports, "deepFreeze", { enumerable: true, get: function () { return deepFreeze_js_1.deepFreeze; } });
 var insecureTokenProvider_js_1 = require("./insecureTokenProvider.js");
@@ -33,4 +33,7 @@ var mockStorage_js_1 = require("./mockStorage.js");
 Object.defineProperty(exports, "MockStorage", { enumerable: true, get: function () { return mockStorage_js_1.MockStorage; } });
 var validateAssertionError_js_1 = require("./validateAssertionError.js");
 Object.defineProperty(exports, "validateAssertionError", { enumerable: true, get: function () { return validateAssertionError_js_1.validateAssertionError; } });
+Object.defineProperty(exports, "validateUsageError", { enumerable: true, get: function () { return validateAssertionError_js_1.validateUsageError; } });
+Object.defineProperty(exports, "validateTypeError", { enumerable: true, get: function () { return validateAssertionError_js_1.validateTypeError; } });
+Object.defineProperty(exports, "validateError", { enumerable: true, get: function () { return validateAssertionError_js_1.validateError; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AAEnB,uEAAmE;AAA1D,iIAAA,qBAAqB,OAAA;AAC9B,uEAAuE;AAA9D,qIAAA,yBAAyB,OAAA;AAClC,iDAAmE;AAA1D,iHAAA,gBAAgB,OAAA;AAAE,+GAAA,cAAc,OAAA;AACzC,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,uCAaoB;AAXnB,gHAAA,oBAAoB,OAAA;AAEpB,uHAAA,2BAA2B,OAAA;AAC3B,+GAAA,mBAAmB,OAAA;AACnB,oHAAA,wBAAwB,OAAA;AACxB,qHAAA,yBAAyB,OAAA;AACzB,oHAAA,wBAAwB,OAAA;AACxB,6GAAA,iBAAiB,OAAA;AACjB,wGAAA,YAAY,OAAA;AACZ,oHAAA,wBAAwB,OAAA;AAGzB,qEAGmC;AAFlC,qJAAA,0CAA0C,OAAA;AAC1C,8IAAA,mCAAmC,OAAA;AAEpC,mDAA+C;AAAtC,6GAAA,WAAW,OAAA;AACpB,yEAAqE;AAA5D,mIAAA,sBAAsB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { deepFreeze } from \"./deepFreeze.js\";\nexport { IInsecureUser } from \"./insecureUsers.js\";\nexport { InsecureTokenProvider } from \"./insecureTokenProvider.js\";\nexport { MockFluidDataStoreContext } from \"./mocksDataStoreContext.js\";\nexport { MockDeltaManager, MockDeltaQueue } from \"./mockDeltas.js\";\nexport { MockHandle } from \"./mockHandle.js\";\nexport {\n\tIMockContainerRuntimePendingMessage,\n\tMockContainerRuntime,\n\tIMockContainerRuntimeOptions,\n\tMockContainerRuntimeFactory,\n\tMockDeltaConnection,\n\tMockEmptyDeltaConnection,\n\tMockFluidDataStoreRuntime,\n\tMockObjectStorageService,\n\tMockQuorumClients,\n\tMockAudience,\n\tMockSharedObjectServices,\n\tIInternalMockRuntimeMessage,\n} from \"./mocks.js\";\nexport {\n\tMockContainerRuntimeFactoryForReconnection,\n\tMockContainerRuntimeForReconnection,\n} from \"./mocksForReconnection.js\";\nexport { MockStorage } from \"./mockStorage.js\";\nexport { validateAssertionError } from \"./validateAssertionError.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AAEnB,uEAAmE;AAA1D,iIAAA,qBAAqB,OAAA;AAC9B,uEAAuE;AAA9D,qIAAA,yBAAyB,OAAA;AAClC,iDAAmE;AAA1D,iHAAA,gBAAgB,OAAA;AAAE,+GAAA,cAAc,OAAA;AACzC,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,uCAaoB;AAXnB,gHAAA,oBAAoB,OAAA;AAEpB,uHAAA,2BAA2B,OAAA;AAC3B,+GAAA,mBAAmB,OAAA;AACnB,oHAAA,wBAAwB,OAAA;AACxB,qHAAA,yBAAyB,OAAA;AACzB,oHAAA,wBAAwB,OAAA;AACxB,6GAAA,iBAAiB,OAAA;AACjB,wGAAA,YAAY,OAAA;AACZ,oHAAA,wBAAwB,OAAA;AAGzB,qEAGmC;AAFlC,qJAAA,0CAA0C,OAAA;AAC1C,8IAAA,mCAAmC,OAAA;AAEpC,mDAA+C;AAAtC,6GAAA,WAAW,OAAA;AACpB,yEAKqC;AAJpC,mIAAA,sBAAsB,OAAA;AACtB,+HAAA,kBAAkB,OAAA;AAClB,8HAAA,iBAAiB,OAAA;AACjB,0HAAA,aAAa,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { deepFreeze } from \"./deepFreeze.js\";\nexport { IInsecureUser } from \"./insecureUsers.js\";\nexport { InsecureTokenProvider } from \"./insecureTokenProvider.js\";\nexport { MockFluidDataStoreContext } from \"./mocksDataStoreContext.js\";\nexport { MockDeltaManager, MockDeltaQueue } from \"./mockDeltas.js\";\nexport { MockHandle } from \"./mockHandle.js\";\nexport {\n\tIMockContainerRuntimePendingMessage,\n\tMockContainerRuntime,\n\tIMockContainerRuntimeOptions,\n\tMockContainerRuntimeFactory,\n\tMockDeltaConnection,\n\tMockEmptyDeltaConnection,\n\tMockFluidDataStoreRuntime,\n\tMockObjectStorageService,\n\tMockQuorumClients,\n\tMockAudience,\n\tMockSharedObjectServices,\n\tIInternalMockRuntimeMessage,\n} from \"./mocks.js\";\nexport {\n\tMockContainerRuntimeFactoryForReconnection,\n\tMockContainerRuntimeForReconnection,\n} from \"./mocksForReconnection.js\";\nexport { MockStorage } from \"./mockStorage.js\";\nexport {\n\tvalidateAssertionError,\n\tvalidateUsageError,\n\tvalidateTypeError,\n\tvalidateError,\n} from \"./validateAssertionError.js\";\n"]}

package/dist/validateAssertionError.d.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 /**
- * Validates that an error thrown by our assert() function has the expected message, or a
+ * Validates that an error thrown by our `assert()` function has the expected message, or a
  * short code that corresponds to that message.
  *
  * @remarks
@@ -12,13 +12,29 @@
  * before the policy-check tool replaces those strings with short codes, or after. Note that
  * it either returns true or throws an error (the behavior expected by NodeJS' `assert.throws()`).
  *
- * @param error - The error object thrown by our `assert()` function. Its `message` property could
- * be a short code, or the original string message coded into the `assert()`.
  * @param expectedErrorMessage - The message that the error object should match (either explicitly,
  * or because it contains a short code which maps to that message).
- * @returns `true` if the message in the error object that was passed in matches the expected
- * message. Otherwise it throws an error.
+ * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.
  * @internal
  */
-export declare function validateAssertionError(error: Error, expectedErrorMsg: string | RegExp): boolean;
+export declare function validateAssertionError(expectedErrorMsg: string | RegExp): (error: Error) => true;
+/**
+ * {@link validateError} for `UsageError`.
+ * @internal
+ */
+export declare function validateUsageError(expectedErrorMsg: string | RegExp): (error: Error) => true;
+/**
+ * {@link validateError} for `TypeError`.
+ * @internal
+ */
+export declare function validateTypeError(expectedErrorMsg: string | RegExp): (error: Error) => true;
+/**
+ * Validates that a specific kind of error was thrown with the expected message.
+ * @remarks
+ * Intended for use with NodeJS's `assert.throws`.
+ * @see {@link validateAssertionError}, {@link validateUsageError}, {@link validateTypeError} for more specialized versions.
+ * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.
+ * @internal
+ */
+export declare function validateError(expectedErrorMsg: string | RegExp, errorType?: new (...args: any[]) => Error): (error: Error) => true;
 //# sourceMappingURL=validateAssertionError.d.ts.map

package/dist/validateAssertionError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateAssertionError.d.ts","sourceRoot":"","sources":["../src/validateAssertionError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,KAAK,EACZ,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAC/B,OAAO,CAqBT"}
+{"version":3,"file":"validateAssertionError.d.ts","sourceRoot":"","sources":["../src/validateAssertionError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACrC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAC/B,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAmBxB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAE5F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAE3F;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,gBAAgB,EAAE,MAAM,GAAG,MAAM,EACjC,SAAS,GAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,KAAa,GAC9C,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAaxB"}

package/dist/validateAssertionError.js

@@ -4,10 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAssertionError = void 0;
+exports.validateError = exports.validateTypeError = exports.validateUsageError = exports.validateAssertionError = void 0;
+const internal_1 = require("@fluidframework/telemetry-utils/internal");
+const internal_2 = require("@fluidframework/core-utils/internal");
 const assertionShortCodesMap_js_1 = require("./assertionShortCodesMap.js");
 /**
- * Validates that an error thrown by our assert() function has the expected message, or a
+ * Validates that an error thrown by our `assert()` function has the expected message, or a
  * short code that corresponds to that message.
  *
  * @remarks
@@ -16,32 +18,68 @@ const assertionShortCodesMap_js_1 = require("./assertionShortCodesMap.js");
  * before the policy-check tool replaces those strings with short codes, or after. Note that
  * it either returns true or throws an error (the behavior expected by NodeJS' `assert.throws()`).
  *
- * @param error - The error object thrown by our `assert()` function. Its `message` property could
- * be a short code, or the original string message coded into the `assert()`.
  * @param expectedErrorMessage - The message that the error object should match (either explicitly,
  * or because it contains a short code which maps to that message).
- * @returns `true` if the message in the error object that was passed in matches the expected
- * message. Otherwise it throws an error.
+ * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.
  * @internal
  */
-function validateAssertionError(error, expectedErrorMsg) {
-    // Asserts with custom debugMessageBuilder put extra content on the second line of the message, even when tagged.
-    // Thus extract the first line, which will be the assert tag if there is one, and replace it with the message from the shortCodeMap.
-    const split = error.message.split("\n");
-    const possibleShortCode = split[0].trim();
-    if (possibleShortCode in assertionShortCodesMap_js_1.shortCodeMap) {
-        split[0] = assertionShortCodesMap_js_1.shortCodeMap[possibleShortCode];
-    }
-    const mappedMsg = split.join("\n");
-    if (typeof expectedErrorMsg === "string"
-        ? mappedMsg !== expectedErrorMsg
-        : !expectedErrorMsg.test(mappedMsg)) {
-        // This throws an Error instead of an AssertionError because AssertionError would require a dependency on the
-        // node assert library, which we don't want to do for this library because it's used in the browser.
-        const message = `Unexpected assertion thrown\nActual: ${error.message === mappedMsg ? error.message : `${error.message} ('${mappedMsg}')}`}\nExpected: ${expectedErrorMsg}`;
-        throw new Error(message);
-    }
-    return true;
+function validateAssertionError(expectedErrorMsg) {
+    return (error) => {
+        // Asserts with custom debugMessageBuilder put extra content on the second line of the message, even when tagged.
+        // Thus extract the first line, which will be the assert tag if there is one, and replace it with the message from the shortCodeMap.
+        const split = error.message.split("\n");
+        const possibleShortCode = split[0].trim();
+        if (possibleShortCode in assertionShortCodesMap_js_1.shortCodeMap) {
+            split[0] = assertionShortCodesMap_js_1.shortCodeMap[possibleShortCode];
+        }
+        const mappedMsg = split.join("\n");
+        if (testErrorMessage(mappedMsg, expectedErrorMsg)) {
+            // This throws an Error instead of an AssertionError because AssertionError would require a dependency on the
+            // node assert library, which we don't want to do for this library because it's used in the browser.
+            const message = `Unexpected assertion thrown\nActual: ${error.message === mappedMsg ? error.message : `${error.message} ('${mappedMsg}')}`}\nExpected: ${expectedErrorMsg}`;
+            throw new Error(message);
+        }
+        return true;
+    };
 }
 exports.validateAssertionError = validateAssertionError;
+/**
+ * {@link validateError} for `UsageError`.
+ * @internal
+ */
+function validateUsageError(expectedErrorMsg) {
+    return validateError(expectedErrorMsg, internal_1.UsageError);
+}
+exports.validateUsageError = validateUsageError;
+/**
+ * {@link validateError} for `TypeError`.
+ * @internal
+ */
+function validateTypeError(expectedErrorMsg) {
+    return validateError(expectedErrorMsg, TypeError);
+}
+exports.validateTypeError = validateTypeError;
+/**
+ * Validates that a specific kind of error was thrown with the expected message.
+ * @remarks
+ * Intended for use with NodeJS's `assert.throws`.
+ * @see {@link validateAssertionError}, {@link validateUsageError}, {@link validateTypeError} for more specialized versions.
+ * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.
+ * @internal
+ */
+function validateError(expectedErrorMsg, errorType = Error) {
+    return (error) => {
+        (0, internal_2.assert)(error instanceof errorType, `Expected an error of type "${errorType.name}", but got "${error}"`);
+        if (testErrorMessage(error.message, expectedErrorMsg)) {
+            throw new Error(`Unexpected ${errorType.name} thrown\nActual: ${error.message}\nExpected: ${expectedErrorMsg}`);
+        }
+        return true;
+    };
+}
+exports.validateError = validateError;
+function testErrorMessage(actualMessage, expectedErrorMsg) {
+    return typeof expectedErrorMsg === "string"
+        ? actualMessage !== expectedErrorMsg
+        : !expectedErrorMsg.test(actualMessage);
+}
 //# sourceMappingURL=validateAssertionError.js.map

package/dist/validateAssertionError.js.map

@@ -1 +1 @@
-{"version":3,"file":"validateAssertionError.js","sourceRoot":"","sources":["../src/validateAssertionError.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2EAA2D;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,sBAAsB,CACrC,KAAY,EACZ,gBAAiC;IAEjC,iHAAiH;IACjH,oIAAoI;IACpI,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC1C,IAAI,iBAAiB,IAAI,wCAAY,EAAE,CAAC;QACvC,KAAK,CAAC,CAAC,CAAC,GAAG,wCAAY,CAAC,iBAAiB,CAAC,CAAC;IAC5C,CAAC;IACD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEnC,IACC,OAAO,gBAAgB,KAAK,QAAQ;QACnC,CAAC,CAAC,SAAS,KAAK,gBAAgB;QAChC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,EACnC,CAAC;QACF,6GAA6G;QAC7G,oGAAoG;QACpG,MAAM,OAAO,GAAG,wCAAwC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,MAAM,SAAS,KAAK,eAAe,gBAAgB,EAAE,CAAC;QAC5K,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAxBD,wDAwBC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { shortCodeMap } from \"./assertionShortCodesMap.js\";\n\n/**\n * Validates that an error thrown by our assert() function has the expected message, or a\n * short code that corresponds to that message.\n *\n * @remarks\n * The main use case for this is so tests that expect specific assert() calls to fail can\n * always do comparisons based on the original string message, and work whether they run\n * before the policy-check tool replaces those strings with short codes, or after. Note that\n * it either returns true or throws an error (the behavior expected by NodeJS' `assert.throws()`).\n *\n * @param error - The error object thrown by our `assert()` function. Its `message` property could\n * be a short code, or the original string message coded into the `assert()`.\n * @param expectedErrorMessage - The message that the error object should match (either explicitly,\n * or because it contains a short code which maps to that message).\n * @returns `true` if the message in the error object that was passed in matches the expected\n * message. Otherwise it throws an error.\n * @internal\n */\nexport function validateAssertionError(\n\terror: Error,\n\texpectedErrorMsg: string | RegExp,\n): boolean {\n\t// Asserts with custom debugMessageBuilder put extra content on the second line of the message, even when tagged.\n\t// Thus extract the first line, which will be the assert tag if there is one, and replace it with the message from the shortCodeMap.\n\tconst split = error.message.split(\"\\n\");\n\tconst possibleShortCode = split[0].trim();\n\tif (possibleShortCode in shortCodeMap) {\n\t\tsplit[0] = shortCodeMap[possibleShortCode];\n\t}\n\tconst mappedMsg = split.join(\"\\n\");\n\n\tif (\n\t\ttypeof expectedErrorMsg === \"string\"\n\t\t\t? mappedMsg !== expectedErrorMsg\n\t\t\t: !expectedErrorMsg.test(mappedMsg)\n\t) {\n\t\t// This throws an Error instead of an AssertionError because AssertionError would require a dependency on the\n\t\t// node assert library, which we don't want to do for this library because it's used in the browser.\n\t\tconst message = `Unexpected assertion thrown\\nActual: ${error.message === mappedMsg ? error.message : `${error.message} ('${mappedMsg}')}`}\\nExpected: ${expectedErrorMsg}`;\n\t\tthrow new Error(message);\n\t}\n\treturn true;\n}\n"]}
+{"version":3,"file":"validateAssertionError.js","sourceRoot":"","sources":["../src/validateAssertionError.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uEAAsE;AACtE,kEAA6D;AAC7D,2EAA2D;AAE3D;;;;;;;;;;;;;;GAcG;AACH,SAAgB,sBAAsB,CACrC,gBAAiC;IAEjC,OAAO,CAAC,KAAY,EAAE,EAAE;QACvB,iHAAiH;QACjH,oIAAoI;QACpI,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC1C,IAAI,iBAAiB,IAAI,wCAAY,EAAE,CAAC;YACvC,KAAK,CAAC,CAAC,CAAC,GAAG,wCAAY,CAAC,iBAAiB,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEnC,IAAI,gBAAgB,CAAC,SAAS,EAAE,gBAAgB,CAAC,EAAE,CAAC;YACnD,6GAA6G;YAC7G,oGAAoG;YACpG,MAAM,OAAO,GAAG,wCAAwC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,MAAM,SAAS,KAAK,eAAe,gBAAgB,EAAE,CAAC;YAC5K,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC,CAAC;AACH,CAAC;AArBD,wDAqBC;AAED;;;GAGG;AACH,SAAgB,kBAAkB,CAAC,gBAAiC;IACnE,OAAO,aAAa,CAAC,gBAAgB,EAAE,qBAAU,CAAC,CAAC;AACpD,CAAC;AAFD,gDAEC;AAED;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,gBAAiC;IAClE,OAAO,aAAa,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;AACnD,CAAC;AAFD,8CAEC;AAED;;;;;;;GAOG;AACH,SAAgB,aAAa,CAC5B,gBAAiC,EACjC,YAA2C,KAAK;IAEhD,OAAO,CAAC,KAAY,EAAE,EAAE;QACvB,IAAA,iBAAM,EACL,KAAK,YAAY,SAAS,EAC1B,8BAA8B,SAAS,CAAC,IAAI,eAAe,KAAK,GAAG,CACnE,CAAC;QACF,IAAI,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,gBAAgB,CAAC,EAAE,CAAC;YACvD,MAAM,IAAI,KAAK,CACd,cAAc,SAAS,CAAC,IAAI,oBAAoB,KAAK,CAAC,OAAO,eAAe,gBAAgB,EAAE,CAC9F,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC,CAAC;AACH,CAAC;AAhBD,sCAgBC;AAED,SAAS,gBAAgB,CAAC,aAAqB,EAAE,gBAAiC;IACjF,OAAO,OAAO,gBAAgB,KAAK,QAAQ;QAC1C,CAAC,CAAC,aAAa,KAAK,gBAAgB;QACpC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport { shortCodeMap } from \"./assertionShortCodesMap.js\";\n\n/**\n * Validates that an error thrown by our `assert()` function has the expected message, or a\n * short code that corresponds to that message.\n *\n * @remarks\n * The main use case for this is so tests that expect specific assert() calls to fail can\n * always do comparisons based on the original string message, and work whether they run\n * before the policy-check tool replaces those strings with short codes, or after. Note that\n * it either returns true or throws an error (the behavior expected by NodeJS' `assert.throws()`).\n *\n * @param expectedErrorMessage - The message that the error object should match (either explicitly,\n * or because it contains a short code which maps to that message).\n * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.\n * @internal\n */\nexport function validateAssertionError(\n\texpectedErrorMsg: string | RegExp,\n): (error: Error) => true {\n\treturn (error: Error) => {\n\t\t// Asserts with custom debugMessageBuilder put extra content on the second line of the message, even when tagged.\n\t\t// Thus extract the first line, which will be the assert tag if there is one, and replace it with the message from the shortCodeMap.\n\t\tconst split = error.message.split(\"\\n\");\n\t\tconst possibleShortCode = split[0].trim();\n\t\tif (possibleShortCode in shortCodeMap) {\n\t\t\tsplit[0] = shortCodeMap[possibleShortCode];\n\t\t}\n\t\tconst mappedMsg = split.join(\"\\n\");\n\n\t\tif (testErrorMessage(mappedMsg, expectedErrorMsg)) {\n\t\t\t// This throws an Error instead of an AssertionError because AssertionError would require a dependency on the\n\t\t\t// node assert library, which we don't want to do for this library because it's used in the browser.\n\t\t\tconst message = `Unexpected assertion thrown\\nActual: ${error.message === mappedMsg ? error.message : `${error.message} ('${mappedMsg}')}`}\\nExpected: ${expectedErrorMsg}`;\n\t\t\tthrow new Error(message);\n\t\t}\n\t\treturn true;\n\t};\n}\n\n/**\n * {@link validateError} for `UsageError`.\n * @internal\n */\nexport function validateUsageError(expectedErrorMsg: string | RegExp): (error: Error) => true {\n\treturn validateError(expectedErrorMsg, UsageError);\n}\n\n/**\n * {@link validateError} for `TypeError`.\n * @internal\n */\nexport function validateTypeError(expectedErrorMsg: string | RegExp): (error: Error) => true {\n\treturn validateError(expectedErrorMsg, TypeError);\n}\n\n/**\n * Validates that a specific kind of error was thrown with the expected message.\n * @remarks\n * Intended for use with NodeJS's `assert.throws`.\n * @see {@link validateAssertionError}, {@link validateUsageError}, {@link validateTypeError} for more specialized versions.\n * @returns an error validation function suitable for use with NodeJS's `assert.throws()`.\n * @internal\n */\nexport function validateError(\n\texpectedErrorMsg: string | RegExp,\n\terrorType: new (...args: any[]) => Error = Error,\n): (error: Error) => true {\n\treturn (error: Error) => {\n\t\tassert(\n\t\t\terror instanceof errorType,\n\t\t\t`Expected an error of type \"${errorType.name}\", but got \"${error}\"`,\n\t\t);\n\t\tif (testErrorMessage(error.message, expectedErrorMsg)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Unexpected ${errorType.name} thrown\\nActual: ${error.message}\\nExpected: ${expectedErrorMsg}`,\n\t\t\t);\n\t\t}\n\t\treturn true;\n\t};\n}\n\nfunction testErrorMessage(actualMessage: string, expectedErrorMsg: string | RegExp): boolean {\n\treturn typeof expectedErrorMsg === \"string\"\n\t\t? actualMessage !== expectedErrorMsg\n\t\t: !expectedErrorMsg.test(actualMessage);\n}\n"]}

package/lib/assertionShortCodesMap.d.ts

@@ -1009,7 +1009,6 @@ export declare const shortCodeMap: {
     "0x7a9": string;
     "0x7aa": string;
     "0x7af": string;
-    "0x7b5": string;
     "0x7b6": string;
     "0x7b7": string;
     "0x7b8": string;
@@ -1154,16 +1153,6 @@ export declare const shortCodeMap: {
     "0x8cd": string;
     "0x8ce": string;
     "0x8cf": string;
-    "0x8d0": string;
-    "0x8d1": string;
-    "0x8d2": string;
-    "0x8d3": string;
-    "0x8d4": string;
-    "0x8d5": string;
-    "0x8d6": string;
-    "0x8d7": string;
-    "0x8d8": string;
-    "0x8d9": string;
     "0x8da": string;
     "0x8db": string;
     "0x8dc": string;
@@ -1198,7 +1187,6 @@ export declare const shortCodeMap: {
     "0x907": string;
     "0x908": string;
     "0x909": string;
-    "0x90e": string;
     "0x911": string;
     "0x916": string;
     "0x921": string;
@@ -1244,7 +1232,6 @@ export declare const shortCodeMap: {
     "0x962": string;
     "0x963": string;
     "0x964": string;
-    "0x965": string;
     "0x966": string;
     "0x967": string;
     "0x969": string;
@@ -1348,7 +1335,6 @@ export declare const shortCodeMap: {
     "0x9f4": string;
     "0x9f5": string;
     "0x9f6": string;
-    "0x9f7": string;
     "0x9f8": string;
     "0x9f9": string;
     "0x9fe": string;
@@ -1595,7 +1581,6 @@ export declare const shortCodeMap: {
     "0xb28": string;
     "0xb29": string;
     "0xb2a": string;
-    "0xb2b": string;
     "0xb2c": string;
     "0xb2d": string;
     "0xb2e": string;
@@ -1788,7 +1773,6 @@ export declare const shortCodeMap: {
     "0xc15": string;
     "0xc16": string;
     "0xc17": string;
-    "0xc19": string;
     "0xc1a": string;
     "0xc1b": string;
     "0xc1e": string;
@@ -1909,5 +1893,12 @@ export declare const shortCodeMap: {
     "0xc9a": string;
     "0xc9b": string;
     "0xc9c": string;
+    "0xc9d": string;
+    "0xc9e": string;
+    "0xc9f": string;
+    "0xca0": string;
+    "0xca1": string;
+    "0xca2": string;
+    "0xca3": string;
 };
 //# sourceMappingURL=assertionShortCodesMap.d.ts.map

package/lib/assertionShortCodesMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertionShortCodesMap.d.ts","sourceRoot":"","sources":["../src/assertionShortCodesMap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi3DxB,CAAC"}
+{"version":3,"file":"assertionShortCodesMap.d.ts","sourceRoot":"","sources":["../src/assertionShortCodesMap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAw2DxB,CAAC"}

package/lib/assertionShortCodesMap.js

@@ -1010,7 +1010,6 @@ export const shortCodeMap = {
     "0x7a9": "Collision during index update",
     "0x7aa": "Unknown removed node ID",
     "0x7af": "Destination must be a new empty detached field",
-    "0x7b5": "kind must be FieldKindWithEditor",
     "0x7b6": "Attach source field must be different from current field",
     "0x7b7": "Attach source field must exist",
     "0x7b8": "Attach must consume all nodes in source field",
@@ -1155,16 +1154,6 @@ export const shortCodeMap = {
     "0x8cd": "detached node should exist",
     "0x8ce": "Both replace replaces should not be undefined",
     "0x8cf": "Both replace replaces should not be undefined",
-    "0x8d0": "Multiple detached nodes",
-    "0x8d1": "Multiple attached nodes",
-    "0x8d2": "Invalid change: pin must have a reserved detach ID",
-    "0x8d3": "Invalid reserved detach ID",
-    "0x8d4": "Invalid change: unexpected reserved detach ID on a change that detaches a node from the field",
-    "0x8d5": "Invalid change: attach must have a reserved detach ID",
-    "0x8d6": "Invalid reserved detach ID",
-    "0x8d7": "Invalid change: unexpected reserved detach ID on a change that detaches a node from the field",
-    "0x8d8": "Invalid detach ID",
-    "0x8d9": "Invalid detach ID",
     "0x8da": "Unexpected node changeset collision",
     "0x8db": "Cannot peek length unless both mark queues are non-empty",
     "0x8dc": "Unexpected collision of new node changes",
@@ -1199,7 +1188,6 @@ export const shortCodeMap = {
     "0x907": "unknown op type",
     "0x908": "unknon type of op",
     "0x909": "should not be called",
-    "0x90e": "Unknown format version",
     "0x911": "Invalid operation on a disposed TreeCheckout",
     "0x916": "invalid value",
     "0x921": "Expected a leaf schema.",
@@ -1245,7 +1233,6 @@ export const shortCodeMap = {
     "0x962": "overwriting wrong cache",
     "0x963": "Invalid InternalTreeNode",
     "0x964": "A tagged change should only contain the tagged revision",
-    "0x965": "Implicit revision should be provided",
     "0x966": "Client id should be present and should be of type string",
     "0x967": "Received message from user not in the quorumClients",
     "0x969": "not connected yet",
@@ -1349,7 +1336,6 @@ export const shortCodeMap = {
     "0x9f4": "Impactful cell rename must target empty cell",
     "0x9f5": "Rename mark must have cell ID",
     "0x9f6": "Expected empty cell",
-    "0x9f7": "Rename must have idOverride",
     "0x9f8": "Rename must have idOverride",
     "0x9f9": "Renames should only target empty cells",
     "0x9fe": "node id should be an absolute route with child id part",
@@ -1596,7 +1582,6 @@ export const shortCodeMap = {
     "0xb28": "missing schema",
     "0xb29": "Expected defined output ID",
     "0xb2a": "Revision must be defined",
-    "0xb2b": "Mark type: NoopMarkType should not be encoded.",
     "0xb2c": "Mark type: NoopMarkType should not be encoded.",
     "0xb2d": "Unable to split mark due to lengths",
     "0xb2e": "missing schema for type in cursor",
@@ -1789,7 +1774,6 @@ export const shortCodeMap = {
     "0xc15": "Expected ObjectNodeStoredSchema",
     "0xc16": "missing schema for array node",
     "0xc17": "Expected MapNodeStoredSchema",
-    "0xc19": "Expected FieldSchemaAlpha",
     "0xc1a": "Expected MapNodeStoredSchema",
     "0xc1b": "Expected at least two types",
     "0xc1e": "Expected a constructed node to be an object",
@@ -1909,6 +1893,13 @@ export const shortCodeMap = {
     "0xc99": "Registered version is not less than the current version.",
     "0xc9a": "Presence capabilities should be empty.",
     "0xc9b": "Presence extension called without own compatibility details",
-    "0xc9c": "Data store context does not implement ContainerExtensionProvider"
+    "0xc9c": "Data store context does not implement ContainerExtensionProvider",
+    "0xc9d": "missing schema",
+    "0xc9e": "Invalid configuration class constructed.",
+    "0xc9f": "Unsupported FieldBatchFormatVersion for incremental chunks; must be v2 or higher",
+    "0xca0": "Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher",
+    "0xca1": "Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher",
+    "0xca2": "localOpActivity must be undefined when entering rollback",
+    "0xca3": "localOpActivity must be undefined when entering applyStashedOp"
 };
 //# sourceMappingURL=assertionShortCodesMap.js.map