@latticexyz/store 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2 → 2.2.18-c2ad22c7feb566e1731ff16e8be291746bdffb3e

package/dist/codegen.cjs

@@ -1,1270 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ts/codegen/index.ts
-var codegen_exports = {};
-__export(codegen_exports, {
-  getSchemaTypeInfo: () => getSchemaTypeInfo,
-  getTableOptions: () => getTableOptions,
-  getUserTypeInfo: () => getUserTypeInfo,
-  renderDecodeSlice: () => renderDecodeSlice,
-  renderDecodeValueType: () => renderDecodeValueType,
-  renderDeleteRecordMethods: () => renderDeleteRecordMethods,
-  renderEncodeArray: () => renderEncodeArray,
-  renderEncodeFieldSingle: () => renderEncodeFieldSingle,
-  renderFieldMethods: () => renderFieldMethods,
-  renderRecordData: () => renderRecordData,
-  renderRecordMethods: () => renderRecordMethods,
-  renderTable: () => renderTable,
-  renderTightCoderAutoTest: () => renderTightCoderAutoTest,
-  renderTightCoderAutoTestFunction: () => renderTightCoderAutoTestFunction,
-  renderTightCoderDecode: () => renderTightCoderDecode,
-  renderTightCoderEncode: () => renderTightCoderEncode,
-  renderTypesFromConfig: () => renderTypesFromConfig,
-  resolveAbiOrUserType: () => resolveAbiOrUserType,
-  tablegen: () => tablegen
-});
-module.exports = __toCommonJS(codegen_exports);
-
-// ts/codegen/field.ts
-var import_codegen = require("@latticexyz/common/codegen");
-function renderFieldMethods(options) {
-  const storeArgument = options.storeArgument;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = (0, import_codegen.renderCommonData)(options);
-  let result = "";
-  for (const [schemaIndex, field] of options.fields.entries()) {
-    if (!options.withDynamicFieldMethods && field.isDynamic) {
-      continue;
-    }
-    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
-    if (options.withGetters) {
-      result += (0, import_codegen.renderWithFieldSuffix)(
-        options.withSuffixlessFieldMethods,
-        field.name,
-        (_methodNameSuffix) => (0, import_codegen.renderWithStore)(
-          storeArgument,
-          ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-            /**
-             * @notice Get ${field.name}${_commentSuffix}.
-             */
-            function ${_methodNamePrefix}get${_methodNameSuffix}(${(0, import_codegen.renderArguments)([
-            _typedStore,
-            _typedTableId,
-            _typedKeyArgs
-          ])}) internal view returns (${_typedFieldName}) {
-              ${_keyTupleDefinition}
-              ${field.isDynamic ? `bytes memory _blob = ${_store}.getDynamicField(
-                      _tableId,
-                      _keyTuple,
-                      ${schemaIndex - options.staticFields.length}
-                    );` : `bytes32 _blob = ${_store}.getStaticField(
-                      _tableId,
-                      _keyTuple,
-                      ${schemaIndex},
-                      _fieldLayout
-                    );`}
-              return ${renderDecodeFieldSingle(field)};
-            }
-          `
-        )
-      );
-    }
-    result += (0, import_codegen.renderWithFieldSuffix)(
-      options.withSuffixlessFieldMethods,
-      field.name,
-      (_methodNameSuffix) => (0, import_codegen.renderWithStore)(storeArgument, ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => {
-        const externalArguments = (0, import_codegen.renderArguments)([_typedStore, _typedTableId, _typedKeyArgs, _typedFieldName]);
-        const setFieldMethod = field.isDynamic ? "setDynamicField" : "setStaticField";
-        const encodeFieldSingle = renderEncodeFieldSingle(field);
-        const internalArguments = field.isDynamic ? `_tableId, _keyTuple, ${schemaIndex - options.staticFields.length}, ${encodeFieldSingle}` : `_tableId, _keyTuple, ${schemaIndex}, ${encodeFieldSingle}, _fieldLayout`;
-        return `
-          /**
-           * @notice Set ${field.name}${_commentSuffix}.
-           */
-          function ${_methodNamePrefix}set${_methodNameSuffix}(${externalArguments}) internal {
-            ${_keyTupleDefinition}
-            ${_store}.${setFieldMethod}(${internalArguments});
-          }
-        `;
-      })
-    );
-    if (field.isDynamic) {
-      const portionData = fieldPortionData(field);
-      const dynamicSchemaIndex = schemaIndex - options.staticFields.length;
-      const { typeWrappingData } = field;
-      if (options.withGetters) {
-        if (typeWrappingData && typeWrappingData.kind === "staticArray") {
-          result += (0, import_codegen.renderWithFieldSuffix)(
-            options.withSuffixlessFieldMethods,
-            field.name,
-            (_methodNameSuffix) => `
-                // The length of ${field.name}
-                uint256 constant length${_methodNameSuffix} = ${typeWrappingData.staticLength};
-              `
-          );
-        } else {
-          result += (0, import_codegen.renderWithFieldSuffix)(
-            options.withSuffixlessFieldMethods,
-            field.name,
-            (_methodNameSuffix) => (0, import_codegen.renderWithStore)(
-              storeArgument,
-              ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-                /**
-                 * @notice Get the length of ${field.name}${_commentSuffix}.
-                 */
-                function ${_methodNamePrefix}length${_methodNameSuffix}(${(0, import_codegen.renderArguments)([
-                _typedStore,
-                _typedTableId,
-                _typedKeyArgs
-              ])}) internal view returns (uint256) {
-                  ${_keyTupleDefinition}
-                  uint256 _byteLength = ${_store}.getDynamicFieldLength(_tableId, _keyTuple, ${dynamicSchemaIndex});
-                  unchecked {
-                    return _byteLength / ${portionData.elementLength};
-                  }
-                }
-              `
-            )
-          );
-        }
-        result += (0, import_codegen.renderWithFieldSuffix)(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => (0, import_codegen.renderWithStore)(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-              /**
-               * @notice Get an item of ${field.name}${_commentSuffix}.
-               * @dev Reverts with Store_IndexOutOfBounds if \`_index\` is out of bounds for the array.
-              */
-              function ${_methodNamePrefix}getItem${_methodNameSuffix}(${(0, import_codegen.renderArguments)([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs,
-              "uint256 _index"
-            ])}) internal view returns (${portionData.typeWithLocation}) {
-                ${_keyTupleDefinition}
-
-                ${// If the index is within the static length,
-            // but ahead of the dynamic length, return zero
-            typeWrappingData && typeWrappingData.kind === "staticArray" && field.arrayElement ? `
-                    uint256 _byteLength = ${_store}.getDynamicFieldLength(_tableId, _keyTuple, ${dynamicSchemaIndex});
-                    uint256 dynamicLength = _byteLength / ${portionData.elementLength};
-                    uint256 staticLength = ${typeWrappingData.staticLength};
-
-                    if (_index < staticLength && _index >= dynamicLength) {
-                      return ${renderCastStaticBytesToType(field.arrayElement, `bytes${field.arrayElement.staticByteLength}(new bytes(0))`)};
-                    }` : ``}
-
-                unchecked {
-                  bytes memory _blob = ${_store}.getDynamicFieldSlice(
-                    _tableId,
-                    _keyTuple,
-                    ${dynamicSchemaIndex},
-                    _index * ${portionData.elementLength},
-                    (_index + 1) * ${portionData.elementLength}
-                  );
-                  return ${portionData.decoded};
-                }
-              }
-            `
-          )
-        );
-      }
-      if (!typeWrappingData || typeWrappingData.kind !== "staticArray") {
-        result += (0, import_codegen.renderWithFieldSuffix)(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => (0, import_codegen.renderWithStore)(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-              /**
-               * @notice Push ${portionData.title} to ${field.name}${_commentSuffix}.
-               */
-              function ${_methodNamePrefix}push${_methodNameSuffix}(${(0, import_codegen.renderArguments)([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs,
-              `${portionData.typeWithLocation} ${portionData.name}`
-            ])}) internal {
-                ${_keyTupleDefinition}
-                ${_store}.pushToDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.encoded});
-              }
-            `
-          )
-        );
-        result += (0, import_codegen.renderWithFieldSuffix)(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => (0, import_codegen.renderWithStore)(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-              /**
-               * @notice Pop ${portionData.title} from ${field.name}${_commentSuffix}.
-               */
-              function ${_methodNamePrefix}pop${_methodNameSuffix}(${(0, import_codegen.renderArguments)([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs
-            ])}) internal {
-                ${_keyTupleDefinition}
-                ${_store}.popFromDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.elementLength});
-              }
-            `
-          )
-        );
-      }
-      result += (0, import_codegen.renderWithFieldSuffix)(
-        options.withSuffixlessFieldMethods,
-        field.name,
-        (_methodNameSuffix) => (0, import_codegen.renderWithStore)(storeArgument, ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => {
-          const externalArguments = (0, import_codegen.renderArguments)([
-            _typedStore,
-            _typedTableId,
-            _typedKeyArgs,
-            "uint256 _index",
-            `${portionData.typeWithLocation} ${portionData.name}`
-          ]);
-          const internalArguments = `
-            _tableId,
-            _keyTuple,
-            ${dynamicSchemaIndex},
-            uint40(_index * ${portionData.elementLength}),
-            uint40(_encoded.length),
-            _encoded 
-          `;
-          return `
-            /**
-             * @notice Update ${portionData.title} of ${field.name}${_commentSuffix} at \`_index\`.
-             */
-            function ${_methodNamePrefix}update${_methodNameSuffix}(${externalArguments}) internal {
-              ${_keyTupleDefinition}
-              unchecked {
-                bytes memory _encoded = ${portionData.encoded};
-                ${_store}.spliceDynamicData(${internalArguments});
-              }
-            }
-          `;
-        })
-      );
-    }
-  }
-  return result;
-}
-function renderEncodeFieldSingle(field) {
-  let func;
-  if (field.arrayElement) {
-    func = "EncodeArray.encode";
-  } else if (field.isDynamic) {
-    func = "bytes";
-  } else {
-    func = "abi.encodePacked";
-  }
-  return `${func}(${field.typeUnwrap}(${field.name}))`;
-}
-function renderDecodeValueType(field, offset) {
-  const { staticByteLength } = field;
-  const innerSlice = `Bytes.getBytes${staticByteLength}(_blob, ${offset})`;
-  return renderCastStaticBytesToType(field, innerSlice);
-}
-function renderCastStaticBytesToType(field, staticBytes) {
-  const { staticByteLength, internalTypeId } = field;
-  const bits = staticByteLength * 8;
-  let result;
-  if (internalTypeId.match(/^uint\d{1,3}$/) || internalTypeId === "address") {
-    result = `${internalTypeId}(${staticBytes})`;
-  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
-    result = `${internalTypeId}(uint${bits}(${staticBytes}))`;
-  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
-    result = staticBytes;
-  } else if (internalTypeId === "bool") {
-    result = `_toBool(uint8(${staticBytes}))`;
-  } else {
-    throw new Error(`Unknown value type id ${internalTypeId}`);
-  }
-  return `${field.typeWrap}(${result})`;
-}
-function fieldPortionData(field) {
-  if (field.arrayElement) {
-    const name = "_element";
-    const elementFieldData = { ...field.arrayElement, arrayElement: void 0, name };
-    return {
-      typeWithLocation: field.arrayElement.typeWithLocation,
-      name,
-      encoded: renderEncodeFieldSingle(elementFieldData),
-      decoded: renderDecodeFieldSingle(elementFieldData),
-      title: "an element",
-      elementLength: field.arrayElement.staticByteLength
-    };
-  } else {
-    const name = "_slice";
-    const elementFieldData = { ...field, name };
-    return {
-      typeWithLocation: `${field.typeId} memory`,
-      name,
-      encoded: renderEncodeFieldSingle(elementFieldData),
-      decoded: renderDecodeFieldSingle(elementFieldData),
-      title: "a slice",
-      elementLength: 1
-    };
-  }
-}
-function renderDecodeFieldSingle(field) {
-  const { isDynamic, arrayElement } = field;
-  if (arrayElement) {
-    return `${field.typeWrap}(
-      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.internalTypeId}()
-    )`;
-  } else if (isDynamic) {
-    return `${field.typeWrap}(${field.internalTypeId}(_blob))`;
-  } else {
-    return renderCastStaticBytesToType(field, `bytes${field.staticByteLength}(_blob)`);
-  }
-}
-
-// ts/codegen/record.ts
-var import_codegen2 = require("@latticexyz/common/codegen");
-function renderRecordMethods(options) {
-  const { structName, storeArgument } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = (0, import_codegen2.renderCommonData)(options);
-  let result = "";
-  if (options.withGetters) {
-    result += (0, import_codegen2.renderWithStore)(
-      storeArgument,
-      ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-        /**
-         * @notice Get the full data${_commentSuffix}.
-         */
-        function ${_methodNamePrefix}get(${(0, import_codegen2.renderArguments)([
-        _typedStore,
-        _typedTableId,
-        _typedKeyArgs
-      ])}) internal view returns (${renderDecodedRecord(options)}) {
-          ${_keyTupleDefinition}
-          
-          (
-            bytes memory _staticData,
-            EncodedLengths _encodedLengths,
-            bytes memory _dynamicData
-            ) = ${_store}.getRecord(_tableId, _keyTuple, _fieldLayout);
-            return decode(_staticData, _encodedLengths, _dynamicData);
-          }
-        `
-    );
-  }
-  result += (0, import_codegen2.renderWithStore)(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-      const externalArguments = (0, import_codegen2.renderArguments)([
-        _typedStore,
-        _typedTableId,
-        _typedKeyArgs,
-        (0, import_codegen2.renderArguments)(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`))
-      ]);
-      const internalArguments = "_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-      return `
-        /** 
-         * @notice Set the full data using individual values${_commentSuffix}.
-         */
-        function ${_methodNamePrefix}set(${externalArguments}) internal {
-          ${renderRecordData(options)}
-
-          ${_keyTupleDefinition}
-
-          ${_store}.setRecord(${internalArguments});
-        }
-    `;
-    }
-  );
-  if (structName !== void 0) {
-    result += (0, import_codegen2.renderWithStore)(
-      storeArgument,
-      ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-        const externalArguments = (0, import_codegen2.renderArguments)([
-          _typedStore,
-          _typedTableId,
-          _typedKeyArgs,
-          `${structName} memory _table`
-        ]);
-        const internalArguments = "_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-        return `
-          /**
-           * @notice Set the full data using the data struct${_commentSuffix}.
-           */
-          function ${_methodNamePrefix}set(${externalArguments}) internal {
-            ${renderRecordData(options, "_table.")}
-
-            ${_keyTupleDefinition}
-
-            ${_store}.setRecord(${internalArguments});
-          }
-      `;
-      }
-    );
-  }
-  result += renderDecodeFunctions(options);
-  return result;
-}
-function renderRecordData(options, namePrefix = "") {
-  let result = "";
-  if (options.staticFields.length > 0) {
-    result += `
-      bytes memory _staticData = encodeStatic(
-        ${(0, import_codegen2.renderArguments)(options.staticFields.map(({ name }) => `${namePrefix}${name}`))}
-      );
-    `;
-  } else {
-    result += `bytes memory _staticData;`;
-  }
-  if (options.dynamicFields.length > 0) {
-    result += `
-      EncodedLengths _encodedLengths = encodeLengths(
-        ${(0, import_codegen2.renderArguments)(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
-      );
-      bytes memory _dynamicData = encodeDynamic(
-        ${(0, import_codegen2.renderArguments)(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
-      );
-    `;
-  } else {
-    result += `
-      EncodedLengths _encodedLengths;
-      bytes memory _dynamicData;
-    `;
-  }
-  return result;
-}
-function renderDeleteRecordMethods(options) {
-  const { storeArgument } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = (0, import_codegen2.renderCommonData)(options);
-  return (0, import_codegen2.renderWithStore)(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-      const externalArguments = (0, import_codegen2.renderArguments)([_typedStore, _typedTableId, _typedKeyArgs]);
-      const internalArguments = "_tableId, _keyTuple" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-      return `
-        /** 
-         * @notice Delete all data for given keys${_commentSuffix}.
-         */
-        function ${_methodNamePrefix}deleteRecord(${externalArguments}) internal {
-          ${_keyTupleDefinition}
-          ${_store}.deleteRecord(${internalArguments});
-        }
-      `;
-    }
-  );
-}
-function renderDecodeFunctions({ structName, fields, staticFields, dynamicFields }) {
-  const renderedDecodedRecord = structName ? `${structName} memory _table` : (0, import_codegen2.renderArguments)(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  const fieldNamePrefix = structName ? "_table." : "";
-  const staticOffsets = staticFields.map(() => 0);
-  let _acc = 0;
-  for (const [index, field] of staticFields.entries()) {
-    staticOffsets[index] = _acc;
-    _acc += field.staticByteLength;
-  }
-  let result = "";
-  if (staticFields.length > 0) {
-    result += `
-      /**
-       * @notice Decode the tightly packed blob of static data using this table's field layout.
-       */
-      function decodeStatic(bytes memory _blob) internal pure returns (${(0, import_codegen2.renderArguments)(
-      staticFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-    )}) {
-        ${(0, import_codegen2.renderList)(
-      staticFields,
-      (field, index) => `
-          ${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
-          `
-    )}
-      }
-    `;
-  }
-  if (dynamicFields.length > 0) {
-    result += `
-      /**
-       * @notice Decode the tightly packed blob of dynamic data using the encoded lengths.
-       */
-      function decodeDynamic(EncodedLengths _encodedLengths, bytes memory _blob) internal pure returns (${(0, import_codegen2.renderArguments)(
-      dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-    )}) {
-        ${(0, import_codegen2.renderList)(
-      dynamicFields,
-      // unchecked is only dangerous if _encodedLengths (and _blob) is invalid,
-      // but it's assumed to be valid, and this function is meant to be mostly used internally
-      (field, index) => {
-        if (index === 0) {
-          return `
-                uint256 _start;
-                uint256 _end;
-                unchecked {
-                  _end = _encodedLengths.atIndex(${index});
-                }
-                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-              `;
-        } else {
-          return `
-                _start = _end;
-                unchecked {
-                  _end += _encodedLengths.atIndex(${index});
-                }
-                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-              `;
-        }
-      }
-    )}
-      }
-    `;
-  }
-  result += `
-    /**
-     * @notice Decode the tightly packed blobs using this table's field layout.
-     * ${staticFields.length > 0 ? "@param _staticData Tightly packed static fields." : ""}
-    * ${dynamicFields.length > 0 ? "@param _encodedLengths Encoded lengths of dynamic fields." : ""}
-    * ${dynamicFields.length > 0 ? "@param _dynamicData Tightly packed dynamic fields." : ""}
-    */
-    function decode(
-      bytes memory ${staticFields.length > 0 ? "_staticData" : ""},
-      EncodedLengths ${dynamicFields.length > 0 ? "_encodedLengths" : ""},
-      bytes memory ${dynamicFields.length > 0 ? "_dynamicData" : ""}
-    ) internal pure returns (${renderedDecodedRecord}) {
-  `;
-  if (staticFields.length > 0) {
-    result += `
-      (${(0, import_codegen2.renderArguments)(staticFields.map((field) => `${fieldNamePrefix}${field.name}`))}) = decodeStatic(_staticData);
-    `;
-  }
-  if (dynamicFields.length > 0) {
-    result += `
-      (${(0, import_codegen2.renderArguments)(
-      dynamicFields.map((field) => `${fieldNamePrefix}${field.name}`)
-    )}) = decodeDynamic(_encodedLengths, _dynamicData);
-    `;
-  }
-  result += `
-    }
-  `;
-  return result;
-}
-function renderDecodedRecord({ structName, fields }) {
-  if (structName) {
-    return `${structName} memory _table`;
-  } else {
-    return (0, import_codegen2.renderArguments)(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  }
-}
-function renderDecodeDynamicFieldPartial(field) {
-  const { typeId, arrayElement, typeWrap } = field;
-  if (arrayElement) {
-    return `${typeWrap}(
-      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()
-    )`;
-  } else {
-    return `${typeWrap}(
-      ${typeId}(
-        SliceLib.getSubslice(_blob, _start, _end).toBytes()
-      )
-    )`;
-  }
-}
-
-// ts/codegen/renderTable.ts
-var import_codegen3 = require("@latticexyz/common/codegen");
-
-// ts/constants.ts
-var WORD_SIZE = 32;
-var WORD_LAST_INDEX = 31;
-var BYTE_TO_BITS = 8;
-var MAX_TOTAL_FIELDS = 28;
-var MAX_DYNAMIC_FIELDS = 5;
-var LayoutOffsets = {
-  TOTAL_LENGTH: (WORD_SIZE - 2) * BYTE_TO_BITS,
-  NUM_STATIC_FIELDS: (WORD_SIZE - 2 - 1) * BYTE_TO_BITS,
-  NUM_DYNAMIC_FIELDS: (WORD_SIZE - 2 - 1 - 1) * BYTE_TO_BITS
-};
-
-// ts/codegen/renderFieldLayout.ts
-function renderFieldLayout(fields) {
-  return `FieldLayout constant _fieldLayout = FieldLayout.wrap(${encodeFieldLayout(fields)});`;
-}
-function encodeFieldLayout(fields) {
-  const staticFields = fields.filter(({ isDynamic }) => !isDynamic);
-  const numDynamicFields = fields.length - staticFields.length;
-  let fieldLayout = 0n;
-  let totalLength = 0;
-  const totalFields = fields.length;
-  if (totalFields > MAX_TOTAL_FIELDS) throw new Error("FieldLayout: too many fields");
-  if (numDynamicFields > MAX_DYNAMIC_FIELDS) throw new Error("FieldLayout: too many dynamic fields");
-  for (let i = 0; i < staticFields.length; i++) {
-    const { isDynamic, staticByteLength } = fields[i];
-    if (isDynamic) throw new Error(`FieldLayout: static type after dynamic type`);
-    totalLength += staticByteLength;
-    fieldLayout |= BigInt(staticByteLength) << BigInt((WORD_LAST_INDEX - 4 - i) * BYTE_TO_BITS);
-  }
-  fieldLayout |= BigInt(totalLength) << BigInt(LayoutOffsets.TOTAL_LENGTH);
-  fieldLayout |= BigInt(staticFields.length) << BigInt(LayoutOffsets.NUM_STATIC_FIELDS);
-  fieldLayout |= BigInt(numDynamicFields) << BigInt(LayoutOffsets.NUM_DYNAMIC_FIELDS);
-  return `0x${fieldLayout.toString(16).padStart(64, "0")}`;
-}
-
-// ts/codegen/renderTable.ts
-var import_internal = require("@latticexyz/protocol-parser/internal");
-function renderTable(options) {
-  const {
-    imports,
-    libraryName,
-    structName,
-    staticResourceData,
-    storeImportPath,
-    fields,
-    staticFields,
-    dynamicFields,
-    withRecordMethods,
-    storeArgument,
-    keyTuple
-  } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = (0, import_codegen3.renderCommonData)(options);
-  return `
-    ${import_codegen3.renderedSolidityHeader}
-
-    // Import store internals
-    import { IStore } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "IStore.sol")}";
-    import { StoreSwitch } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "StoreSwitch.sol")}";
-    import { StoreCore } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "StoreCore.sol")}";
-    import { Bytes } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "Bytes.sol")}";
-    import { Memory } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "Memory.sol")}";
-    import { SliceLib } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "Slice.sol")}";
-    import { EncodeArray } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "tightcoder/EncodeArray.sol")}";
-    import { FieldLayout } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "FieldLayout.sol")}";
-    import { Schema } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "Schema.sol")}";
-    import { EncodedLengths, EncodedLengthsLib } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "EncodedLengths.sol")}";
-    import { ResourceId } from "${(0, import_codegen3.renderImportPath)(storeImportPath, "ResourceId.sol")}";
-
-    ${imports.length > 0 ? `
-          // Import user types
-          ${(0, import_codegen3.renderImports)(imports)}
-          ` : ""}
-
-    ${!structName ? "" : `
-          struct ${structName} {
-            ${(0, import_codegen3.renderList)(fields, ({ name, typeId }) => `${typeId} ${name};`)}
-          }
-          `}
-
-    library ${libraryName} {
-      ${staticResourceData ? (0, import_codegen3.renderTableId)(staticResourceData) : ""}
-  
-      ${renderFieldLayout(fields)}
-
-      // Hex-encoded key schema of (${keyTuple.map((field) => field.internalTypeId).join(", ")})
-      Schema constant _keySchema = Schema.wrap(${(0, import_internal.keySchemaToHex)(
-    Object.fromEntries(keyTuple.map((field) => [field.name, field.internalTypeId]))
-  )});
-      // Hex-encoded value schema of (${fields.map((field) => field.internalTypeId).join(", ")})
-      Schema constant _valueSchema = Schema.wrap(${(0, import_internal.valueSchemaToHex)(
-    Object.fromEntries(fields.map((field) => [field.name, field.internalTypeId]))
-  )});
-
-      /**
-       * @notice Get the table's key field names.
-       * @return keyNames An array of strings with the names of key fields.
-       */
-      function getKeyNames() internal pure returns (string[] memory keyNames) {
-        keyNames = new string[](${keyTuple.length});
-        ${(0, import_codegen3.renderList)(keyTuple, (keyElement, index) => `keyNames[${index}] = "${keyElement.name}";`)}
-      }
-
-      /**
-       * @notice Get the table's value field names.
-       * @return fieldNames An array of strings with the names of value fields.
-       */
-      function getFieldNames() internal pure returns (string[] memory fieldNames) {
-        fieldNames = new string[](${fields.length});
-        ${(0, import_codegen3.renderList)(fields, (field, index) => `fieldNames[${index}] = "${field.name}";`)}
-      }
-
-      ${(0, import_codegen3.renderWithStore)(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
-          /**
-           * @notice Register the table with its config${_commentSuffix}.
-           */
-          function ${_methodNamePrefix}register(${(0, import_codegen3.renderArguments)([_typedStore, _typedTableId])}) internal {
-            ${_store}.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
-          }
-        `
-  )}
-
-      ${renderFieldMethods(options)}
-
-      ${withRecordMethods ? renderRecordMethods(options) : ""}
-
-      ${renderDeleteRecordMethods(options)}
-
-      ${renderEncodeStatic(staticFields)}
-
-      ${renderEncodeLengths(dynamicFields)}
-
-      ${renderEncodeDynamic(dynamicFields)}
-
-      /**
-       * @notice Encode all of a record's fields.
-       * @return The static (fixed length) data, encoded into a sequence of bytes.
-       * @return The lengths of the dynamic fields (packed into a single bytes32 value).
-       * @return The dynamic (variable length) data, encoded into a sequence of bytes.
-       */
-      function encode(${(0, import_codegen3.renderArguments)(
-    options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
-        ${renderRecordData(options)}
-
-        return (_staticData, _encodedLengths, _dynamicData);
-      }
-      
-      /**
-       * @notice Encode keys as a bytes32 array using this table's field layout.
-       */
-      function encodeKeyTuple(${(0, import_codegen3.renderArguments)([_typedKeyArgs])}) internal pure returns (bytes32[] memory) {
-        ${_keyTupleDefinition}
-        return _keyTuple;
-      }
-    }
-
-    ${(0, import_codegen3.renderTypeHelpers)(options)}
-  `;
-}
-function renderEncodeStatic(staticFields) {
-  if (staticFields.length === 0) return "";
-  return `
-    /**
-     * @notice Tightly pack static (fixed length) data using this table's schema.
-     * @return The static data, encoded into a sequence of bytes.
-     */
-    function encodeStatic(${(0, import_codegen3.renderArguments)(
-    staticFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${(0, import_codegen3.renderArguments)(staticFields.map(({ name }) => name))});
-    }
-  `;
-}
-function renderEncodeLengths(dynamicFields) {
-  if (dynamicFields.length === 0) return "";
-  return `
-    /**
-     * @notice Tightly pack dynamic data lengths using this table's schema.
-     * @return _encodedLengths The lengths of the dynamic fields (packed into a single bytes32 value).
-     */
-    function encodeLengths(${(0, import_codegen3.renderArguments)(
-    dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (EncodedLengths _encodedLengths) {
-      // Lengths are effectively checked during copy by 2**40 bytes exceeding gas limits
-      unchecked {
-        _encodedLengths = EncodedLengthsLib.pack(
-          ${(0, import_codegen3.renderArguments)(
-    dynamicFields.map(({ name, arrayElement }) => {
-      if (arrayElement) {
-        return `${name}.length * ${arrayElement.staticByteLength}`;
-      } else {
-        return `bytes(${name}).length`;
-      }
-    })
-  )}
-        );
-      }
-    }
-  `;
-}
-function renderEncodeDynamic(dynamicFields) {
-  if (dynamicFields.length === 0) return "";
-  return `
-    /**
-     * @notice Tightly pack dynamic (variable length) data using this table's schema.
-     * @return The dynamic data, encoded into a sequence of bytes.
-     */
-    function encodeDynamic(${(0, import_codegen3.renderArguments)(
-    dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${(0, import_codegen3.renderArguments)(dynamicFields.map((field) => renderEncodeFieldSingle(field)))});
-    }
-  `;
-}
-
-// ts/codegen/renderTypesFromConfig.ts
-var import_codegen4 = require("@latticexyz/common/codegen");
-function renderTypesFromConfig(config) {
-  return (0, import_codegen4.renderEnums)(config.enums);
-}
-
-// ts/codegen/tablegen.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_codegen6 = require("@latticexyz/common/codegen");
-
-// ts/codegen/renderTableIndex.ts
-var import_codegen5 = require("@latticexyz/common/codegen");
-var import_node_path = __toESM(require("path"), 1);
-function renderTableIndex(codegenIndexPath, options) {
-  return `
-    ${import_codegen5.renderedSolidityHeader}
-
-    ${(0, import_codegen5.renderList)(options, ({ outputPath, tableName, renderOptions: { structName } }) => {
-    const imports = [tableName];
-    if (structName) imports.push(structName);
-    return `import { ${imports.join(", ")} } from "${(0, import_codegen5.renderImportPath)("./" + import_node_path.default.relative(import_node_path.default.dirname(codegenIndexPath), outputPath))}";`;
-  })}
-  `;
-}
-
-// ts/codegen/tablegen.ts
-var import_utils3 = require("@latticexyz/common/utils");
-
-// ts/codegen/getUserTypesFilename.ts
-var import_node_path2 = __toESM(require("path"), 1);
-function getUserTypesFilename({ config }) {
-  return import_node_path2.default.join(config.sourceDirectory, config.codegen.outputDirectory, config.codegen.userTypesFilename);
-}
-
-// ts/codegen/getUserTypes.ts
-var import_utils = require("@latticexyz/common/utils");
-function getUserTypes({ config }) {
-  const enums = Object.keys(config.enums).map(
-    (name) => ({
-      type: "enum",
-      name,
-      abiType: "uint8",
-      importPath: "./" + getUserTypesFilename({ config })
-    })
-  );
-  const userTypes = Object.entries(config.userTypes).map(
-    ([name, userType]) => ({
-      type: "userType",
-      name,
-      abiType: userType.type,
-      // If `userType.filePath` starts with a `.`, it's relative to the root dir
-      importPath: userType.filePath
-    })
-  );
-  const result = [...enums, ...userTypes];
-  const duplicates = Array.from((0, import_utils.groupBy)(result, (userType) => userType.name).entries()).filter(([, entries]) => entries.length > 1).map(([name]) => name);
-  if (duplicates.length > 0) {
-    throw new Error(`Found enums and user types sharing the same name: ${duplicates.join(", ")}`);
-  }
-  return result;
-}
-
-// ts/codegen/getTableOptions.ts
-var import_path = __toESM(require("path"), 1);
-var import_deprecated2 = require("@latticexyz/schema-type/deprecated");
-
-// ts/codegen/userType.ts
-var import_deprecated = require("@latticexyz/schema-type/deprecated");
-function parseStaticArray(abiType) {
-  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
-  if (!matches) return null;
-  return {
-    elementType: matches[1],
-    staticLength: Number.parseInt(matches[2])
-  };
-}
-function resolveAbiOrUserType(abiOrUserType, userTypes) {
-  if (abiOrUserType in import_deprecated.AbiTypeToSchemaType) {
-    const schemaType = import_deprecated.AbiTypeToSchemaType[abiOrUserType];
-    return {
-      schemaType,
-      renderType: getSchemaTypeInfo(schemaType)
-    };
-  }
-  const staticArray = parseStaticArray(abiOrUserType);
-  if (staticArray) {
-    if (staticArray.elementType in import_deprecated.AbiTypeToSchemaType) {
-      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
-    } else {
-      throw new Error("Static arrays of user types are not supported");
-    }
-  }
-  const userType = userTypes.find((type) => type.name === abiOrUserType);
-  if (!userType) {
-    throw new Error(`User type "${abiOrUserType}" not found`);
-  }
-  return getUserTypeInfo(userType);
-}
-function getSchemaTypeInfo(schemaType) {
-  const staticByteLength = (0, import_deprecated.getStaticByteLength)(schemaType);
-  const isDynamic = staticByteLength === 0;
-  const typeId = import_deprecated.SchemaTypeToAbiType[schemaType];
-  return {
-    typeId,
-    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
-    enumName: import_deprecated.SchemaType[schemaType],
-    staticByteLength,
-    isDynamic,
-    typeWrap: "",
-    typeUnwrap: "",
-    internalTypeId: typeId
-  };
-}
-function getUserTypeInfo(userType) {
-  switch (userType.type) {
-    case "enum": {
-      const schemaType = import_deprecated.SchemaType.UINT8;
-      const staticByteLength = (0, import_deprecated.getStaticByteLength)(schemaType);
-      const isDynamic = staticByteLength === 0;
-      return {
-        schemaType,
-        renderType: {
-          typeId: userType.name,
-          typeWithLocation: userType.name,
-          enumName: import_deprecated.SchemaType[schemaType],
-          staticByteLength,
-          isDynamic,
-          typeWrap: userType.name,
-          typeUnwrap: userType.abiType,
-          internalTypeId: userType.abiType
-        }
-      };
-    }
-    case "userType": {
-      const schemaType = import_deprecated.AbiTypeToSchemaType[userType.abiType];
-      return {
-        schemaType,
-        renderType: {
-          typeId: userType.name,
-          typeWithLocation: userType.name,
-          enumName: import_deprecated.SchemaType[schemaType],
-          staticByteLength: (0, import_deprecated.getStaticByteLength)(schemaType),
-          isDynamic: false,
-          typeWrap: `${userType.name}.wrap`,
-          typeUnwrap: `${userType.name}.unwrap`,
-          internalTypeId: userType.abiType
-        }
-      };
-    }
-  }
-}
-function getStaticArrayTypeInfo(abiType, elementType, staticLength) {
-  const internalTypeId = elementType + "[]";
-  const schemaType = import_deprecated.AbiTypeToSchemaType[internalTypeId];
-  return {
-    schemaType,
-    renderType: {
-      typeId: abiType,
-      typeWithLocation: `${abiType} memory`,
-      enumName: import_deprecated.SchemaType[schemaType],
-      staticByteLength: 0,
-      isDynamic: true,
-      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
-      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
-      typeWrappingData: {
-        kind: "staticArray",
-        elementType,
-        staticLength
-      },
-      internalTypeId
-    }
-  };
-}
-
-// ts/codegen/getTableOptions.ts
-var import_internal2 = require("@latticexyz/protocol-parser/internal");
-var import_utils2 = require("@latticexyz/common/utils");
-function getTableOptions({
-  tables,
-  rootDir,
-  codegenDir,
-  userTypes,
-  storeImportPath
-}) {
-  const options = tables.map((table) => {
-    const outputPath = import_path.default.join(rootDir, codegenDir, table.codegen.outputDirectory, `${table.label}.sol`);
-    const keySchema = (0, import_internal2.getKeySchema)(table);
-    const valueSchema = (0, import_internal2.getValueSchema)(table);
-    const withStruct = table.codegen.dataStruct;
-    const withRecordMethods = withStruct || table.type === "offchainTable" || Object.keys(valueSchema).length > 1;
-    const withSuffixlessFieldMethods = !withRecordMethods && Object.keys(valueSchema).length === 1;
-    const imports = Object.values(table.schema).map((field) => userTypes.find((type) => type.name === field.internalType)).filter(import_utils2.isDefined).map((userType) => {
-      return {
-        // If it's a fully qualified name, remove trailing references
-        // This enables support for user types inside libraries
-        symbol: userType.name.replace(/\..*$/, ""),
-        path: userType.importPath.startsWith(".") ? "./" + import_path.default.relative(import_path.default.dirname(outputPath), import_path.default.join(rootDir, userType.importPath)) : userType.importPath
-      };
-    });
-    const keyTuple = Object.entries(keySchema).map(([name, field]) => {
-      const { renderType } = resolveAbiOrUserType(field.internalType, userTypes);
-      return {
-        ...renderType,
-        name,
-        isDynamic: false
-      };
-    });
-    const fields = Object.entries(valueSchema).map(([name, field]) => {
-      const { renderType, schemaType } = resolveAbiOrUserType(field.internalType, userTypes);
-      const elementType = import_deprecated2.SchemaTypeArrayToElement[schemaType];
-      return {
-        ...renderType,
-        arrayElement: elementType !== void 0 ? getSchemaTypeInfo(elementType) : void 0,
-        name
-      };
-    });
-    const staticFields = fields.filter(({ isDynamic }) => !isDynamic);
-    const dynamicFields = fields.filter(({ isDynamic }) => isDynamic);
-    const staticResourceData = table.codegen.tableIdArgument ? void 0 : {
-      namespace: table.namespace,
-      name: table.name,
-      offchainOnly: table.type === "offchainTable"
-    };
-    return {
-      outputPath,
-      tableName: table.label,
-      renderOptions: {
-        imports,
-        libraryName: table.label,
-        structName: withStruct ? table.label + "Data" : void 0,
-        staticResourceData,
-        storeImportPath: storeImportPath.startsWith(".") ? "./" + import_path.default.relative(import_path.default.dirname(outputPath), import_path.default.join(rootDir, storeImportPath)) : storeImportPath,
-        keyTuple,
-        fields,
-        staticFields,
-        dynamicFields,
-        withGetters: table.type === "table",
-        withRecordMethods,
-        withDynamicFieldMethods: table.type === "table",
-        withSuffixlessFieldMethods,
-        storeArgument: table.codegen.storeArgument
-      }
-    };
-  });
-  return options;
-}
-
-// ts/codegen/tablegen.ts
-var import_debug = __toESM(require("debug"), 1);
-async function tablegen({ rootDir, config }) {
-  const userTypes = getUserTypes({ config });
-  if (Object.keys(config.enums).length > 0) {
-    const userTypesFilename = import_node_path3.default.join(rootDir, getUserTypesFilename({ config }));
-    const source = (0, import_codegen6.renderEnums)(config.enums);
-    await (0, import_codegen6.formatAndWriteSolidity)(source, userTypesFilename, "Generated types file with enums");
-  }
-  await Promise.all(
-    Object.values(config.namespaces).map(async (namespace) => {
-      const sourceDir = config.multipleNamespaces ? import_node_path3.default.join(config.sourceDirectory, "namespaces", namespace.label) : config.sourceDirectory;
-      const codegenDir = import_node_path3.default.join(sourceDir, config.codegen.outputDirectory);
-      const tables = Object.values(namespace.tables);
-      if (tables.length === 0) return;
-      const tableOptions = getTableOptions({
-        tables,
-        rootDir,
-        codegenDir,
-        userTypes,
-        storeImportPath: config.codegen.storeImportPath
-      });
-      const tableDirs = (0, import_utils3.uniqueBy)(
-        tableOptions.map(({ outputPath }) => import_node_path3.default.dirname(outputPath)),
-        (dir) => dir
-      );
-      await Promise.all(tableDirs.map((dir) => import_promises.default.rm(dir, { recursive: true, force: true })));
-      await Promise.all(
-        tableOptions.map(async ({ outputPath, renderOptions }) => {
-          const source = renderTable(renderOptions);
-          return await (0, import_codegen6.formatAndWriteSolidity)(source, outputPath, "Generated table");
-        })
-      );
-      if (config.codegen.indexFilename !== false && tableOptions.length > 0) {
-        const codegenIndexPath = import_node_path3.default.join(rootDir, codegenDir, config.codegen.indexFilename);
-        const source = renderTableIndex(codegenIndexPath, tableOptions);
-        await (0, import_codegen6.formatAndWriteSolidity)(source, codegenIndexPath, "Generated table index");
-      }
-    })
-  );
-  (0, import_debug.default)("Generated tables");
-}
-
-// ts/codegen/tightcoder/renderDecodeSlice.ts
-var import_codegen8 = require("@latticexyz/common/codegen");
-var import_internal3 = require("@latticexyz/schema-type/internal");
-
-// ts/codegen/tightcoder/renderFunctions.ts
-var import_codegen7 = require("@latticexyz/common/codegen");
-function renderTightCoderDecode(element) {
-  return `
-    /**
-     * @notice Decodes a slice into an array of ${element.internalTypeId}.
-     * @dev Uses TightCoder for initial decoding, and then assembly for memory conversion.
-     * @param _input The slice to decode.
-     * @return _output The decoded array of ${element.internalTypeId}.
-     */
-    function decodeArray_${element.internalTypeId}(
-      Slice _input
-    ) internal pure returns (
-      ${element.internalTypeId}[] memory _output
-    ) {
-      bytes32[] memory _genericArray = TightCoder.decode(
-        _input,
-        ${element.staticByteLength},
-        ${(0, import_codegen7.getLeftPaddingBits)(element)}
-      );
-      assembly {
-        _output := _genericArray
-      }
-    }
-  `;
-}
-function renderTightCoderEncode(element) {
-  return `
-
-    /**
-     * @notice Encodes an array of ${element.internalTypeId} into a tightly packed bytes representation.
-     * @param _input The array of ${element.internalTypeId} values to be encoded.
-     * @return The resulting tightly packed bytes representation of the input array.
-     */
-    function encode(${element.internalTypeId}[] memory _input) internal pure returns (bytes memory) {
-      bytes32[] memory _genericArray;
-      assembly {
-        _genericArray := _input
-      }
-      return TightCoder.encode(
-        _genericArray,
-        ${element.staticByteLength},
-        ${(0, import_codegen7.getLeftPaddingBits)(element)}
-      );
-    }
-  `;
-}
-
-// ts/codegen/tightcoder/renderDecodeSlice.ts
-function renderDecodeSlice() {
-  return `
-    ${import_codegen8.renderedSolidityHeader}
-    import { TightCoder } from "./TightCoder.sol";
-    import { Slice } from "../Slice.sol";
-
-    /**
-     * @title DecodeSlice Library 
-     * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
-     * @notice A library for decoding slices of data into specific data types.
-     * @dev This library provides functions for decoding slices into arrays of basic uint types.
-     */
-    library DecodeSlice {
-      ${import_internal3.staticAbiTypes.map(
-    (staticAbiType) => renderTightCoderDecode({
-      internalTypeId: staticAbiType,
-      staticByteLength: import_internal3.staticAbiTypeToByteLength[staticAbiType]
-    })
-  ).join("\n")}
-    }
-  `;
-}
-
-// ts/codegen/tightcoder/renderEncodeArray.ts
-var import_codegen9 = require("@latticexyz/common/codegen");
-var import_internal4 = require("@latticexyz/schema-type/internal");
-function renderEncodeArray() {
-  return `
-    ${import_codegen9.renderedSolidityHeader}
-    import { TightCoder } from "./TightCoder.sol";
-
-    /**
-     * @title EncodeArray 
-     * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
-     * @dev This library provides utilities for encoding arrays into tightly packed bytes representations.
-     */
-    library EncodeArray {
-      ${import_internal4.staticAbiTypes.map(
-    (staticAbiType) => renderTightCoderEncode({
-      internalTypeId: staticAbiType,
-      staticByteLength: import_internal4.staticAbiTypeToByteLength[staticAbiType]
-    })
-  ).join("\n")}
-      }
-  `;
-}
-
-// ts/codegen/tightcoder/renderTightCoderAutoTest.ts
-var import_codegen10 = require("@latticexyz/common/codegen");
-var import_internal5 = require("@latticexyz/schema-type/internal");
-function renderTightCoderAutoTestFunction({ typeId }) {
-  return `
-    function testEncodeDecodeArray_${typeId}(
-      ${typeId} val0,
-      ${typeId} val1,
-      ${typeId} val2
-    ) public {
-      ${typeId}[] memory input = new ${typeId}[](3);
-      input[0] = val0;
-      input[1] = val1;
-      input[2] = val2;
-
-      bytes memory encoded = EncodeArray.encode(input);
-      assertEq(encoded, abi.encodePacked(val0, val1, val2));
-
-      ${typeId}[] memory decoded = SliceLib.fromBytes(encoded).decodeArray_${typeId}();
-      assertEq(decoded.length, 3);
-      assertEq(decoded[0], val0);
-      assertEq(decoded[1], val1);
-      assertEq(decoded[2], val2);
-    }
-  `;
-}
-function renderTightCoderAutoTest() {
-  return `
-    ${import_codegen10.renderedSolidityHeader}
-
-    import { Test } from "forge-std/Test.sol";
-    import { EncodeArray } from "../../src/tightcoder/EncodeArray.sol";
-    import { SliceLib } from "../../src/Slice.sol";
-
-    contract TightCoderAutoTest is Test {
-      ${import_internal5.staticAbiTypes.map((staticAbiType) => renderTightCoderAutoTestFunction({ typeId: staticAbiType })).join("")}
-    }
-  `;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSchemaTypeInfo,
-  getTableOptions,
-  getUserTypeInfo,
-  renderDecodeSlice,
-  renderDecodeValueType,
-  renderDeleteRecordMethods,
-  renderEncodeArray,
-  renderEncodeFieldSingle,
-  renderFieldMethods,
-  renderRecordData,
-  renderRecordMethods,
-  renderTable,
-  renderTightCoderAutoTest,
-  renderTightCoderAutoTestFunction,
-  renderTightCoderDecode,
-  renderTightCoderEncode,
-  renderTypesFromConfig,
-  resolveAbiOrUserType,
-  tablegen
-});
-//# sourceMappingURL=codegen.cjs.map