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

package/dist/codegen.js

@@ -1,669 +1,262 @@
-// ts/codegen/field.ts
-import {
-  renderArguments,
-  renderCommonData,
-  renderWithFieldSuffix,
-  renderWithStore
-} from "@latticexyz/common/codegen";
-function renderFieldMethods(options) {
-  const storeArgument = options.storeArgument;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = 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 += renderWithFieldSuffix(
-        options.withSuffixlessFieldMethods,
-        field.name,
-        (_methodNameSuffix) => renderWithStore(
-          storeArgument,
-          ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,renderWithStore as D}from"@latticexyz/common/codegen";function K(e){let t=e.storeArgument,{_typedTableId:n,_typedKeyArgs:r,_keyTupleDefinition:s}=se(e),i="";for(let[a,d]of e.fields.entries()){if(!e.withDynamicFieldMethods&&d.isDynamic)continue;let y=`${d.typeWithLocation} ${d.name}`;if(e.withGetters&&(i+=_(e.withSuffixlessFieldMethods,d.name,o=>D(t,({_typedStore:c,_store:l,_commentSuffix:u,_methodNamePrefix:h})=>`
             /**
-             * @notice Get ${field.name}${_commentSuffix}.
+             * @notice Get ${d.name}${u}.
              */
-            function ${_methodNamePrefix}get${_methodNameSuffix}(${renderArguments([
-            _typedStore,
-            _typedTableId,
-            _typedKeyArgs
-          ])}) internal view returns (${_typedFieldName}) {
-              ${_keyTupleDefinition}
-              ${field.isDynamic ? `bytes memory _blob = ${_store}.getDynamicField(
+            function ${h}get${o}(${S([c,n,r])}) internal view returns (${y}) {
+              ${s}
+              ${d.isDynamic?`bytes memory _blob = ${l}.getDynamicField(
                       _tableId,
                       _keyTuple,
-                      ${schemaIndex - options.staticFields.length}
-                    );` : `bytes32 _blob = ${_store}.getStaticField(
+                      ${a-e.staticFields.length}
+                    );`:`bytes32 _blob = ${l}.getStaticField(
                       _tableId,
                       _keyTuple,
-                      ${schemaIndex},
+                      ${a},
                       _fieldLayout
                     );`}
-              return ${renderDecodeFieldSingle(field)};
+              return ${N(d)};
             }
-          `
-        )
-      );
-    }
-    result += renderWithFieldSuffix(
-      options.withSuffixlessFieldMethods,
-      field.name,
-      (_methodNameSuffix) => renderWithStore(storeArgument, ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => {
-        const externalArguments = 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 `
+          `))),i+=_(e.withSuffixlessFieldMethods,d.name,o=>D(t,({_typedStore:c,_store:l,_commentSuffix:u,_methodNamePrefix:h})=>{let f=S([c,n,r,y]),m=d.isDynamic?"setDynamicField":"setStaticField",p=E(d),L=d.isDynamic?`_tableId, _keyTuple, ${a-e.staticFields.length}, ${p}`:`_tableId, _keyTuple, ${a}, ${p}, _fieldLayout`;return`
           /**
-           * @notice Set ${field.name}${_commentSuffix}.
+           * @notice Set ${d.name}${u}.
            */
-          function ${_methodNamePrefix}set${_methodNameSuffix}(${externalArguments}) internal {
-            ${_keyTupleDefinition}
-            ${_store}.${setFieldMethod}(${internalArguments});
+          function ${h}set${o}(${f}) internal {
+            ${s}
+            ${l}.${m}(${L});
           }
-        `;
-      })
-    );
-    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 += renderWithFieldSuffix(
-            options.withSuffixlessFieldMethods,
-            field.name,
-            (_methodNameSuffix) => `
-                // The length of ${field.name}
-                uint256 constant length${_methodNameSuffix} = ${typeWrappingData.staticLength};
-              `
-          );
-        } else {
-          result += renderWithFieldSuffix(
-            options.withSuffixlessFieldMethods,
-            field.name,
-            (_methodNameSuffix) => renderWithStore(
-              storeArgument,
-              ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+        `})),d.isDynamic){let o=ce(d),c=a-e.staticFields.length,{typeWrappingData:l}=d;e.withGetters&&(l&&l.kind==="staticArray"?i+=_(e.withSuffixlessFieldMethods,d.name,u=>`
+                // The length of ${d.name}
+                uint256 constant length${u} = ${l.staticLength};
+              `):i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
                 /**
-                 * @notice Get the length of ${field.name}${_commentSuffix}.
+                 * @notice Get the length of ${d.name}${m}.
                  */
-                function ${_methodNamePrefix}length${_methodNameSuffix}(${renderArguments([
-                _typedStore,
-                _typedTableId,
-                _typedKeyArgs
-              ])}) internal view returns (uint256) {
-                  ${_keyTupleDefinition}
-                  uint256 _byteLength = ${_store}.getDynamicFieldLength(_tableId, _keyTuple, ${dynamicSchemaIndex});
+                function ${p}length${u}(${S([h,n,r])}) internal view returns (uint256) {
+                  ${s}
+                  uint256 _byteLength = ${f}.getDynamicFieldLength(_tableId, _keyTuple, ${c});
                   unchecked {
-                    return _byteLength / ${portionData.elementLength};
+                    return _byteLength / ${o.elementLength};
                   }
                 }
-              `
-            )
-          );
-        }
-        result += renderWithFieldSuffix(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => renderWithStore(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+              `)),i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
               /**
-               * @notice Get an item of ${field.name}${_commentSuffix}.
+               * @notice Get an item of ${d.name}${m}.
                * @dev Reverts with Store_IndexOutOfBounds if \`_index\` is out of bounds for the array.
               */
-              function ${_methodNamePrefix}getItem${_methodNameSuffix}(${renderArguments([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs,
-              "uint256 _index"
-            ])}) internal view returns (${portionData.typeWithLocation}) {
-                ${_keyTupleDefinition}
+              function ${p}getItem${u}(${S([h,n,r,"uint256 _index"])}) internal view returns (${o.typeWithLocation}) {
+                ${s}
 
-                ${// 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};
+                ${l&&l.kind==="staticArray"&&d.arrayElement?`
+                    uint256 _byteLength = ${f}.getDynamicFieldLength(_tableId, _keyTuple, ${c});
+                    uint256 dynamicLength = _byteLength / ${o.elementLength};
+                    uint256 staticLength = ${l.staticLength};
 
                     if (_index < staticLength && _index >= dynamicLength) {
-                      return ${renderCastStaticBytesToType(field.arrayElement, `bytes${field.arrayElement.staticByteLength}(new bytes(0))`)};
-                    }` : ``}
+                      return ${W(d.arrayElement,`bytes${d.arrayElement.staticByteLength}(new bytes(0))`)};
+                    }`:""}
 
                 unchecked {
-                  bytes memory _blob = ${_store}.getDynamicFieldSlice(
+                  bytes memory _blob = ${f}.getDynamicFieldSlice(
                     _tableId,
                     _keyTuple,
-                    ${dynamicSchemaIndex},
-                    _index * ${portionData.elementLength},
-                    (_index + 1) * ${portionData.elementLength}
+                    ${c},
+                    _index * ${o.elementLength},
+                    (_index + 1) * ${o.elementLength}
                   );
-                  return ${portionData.decoded};
+                  return ${o.decoded};
                 }
               }
-            `
-          )
-        );
-      }
-      if (!typeWrappingData || typeWrappingData.kind !== "staticArray") {
-        result += renderWithFieldSuffix(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => renderWithStore(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+            `))),(!l||l.kind!=="staticArray")&&(i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
               /**
-               * @notice Push ${portionData.title} to ${field.name}${_commentSuffix}.
+               * @notice Push ${o.title} to ${d.name}${m}.
                */
-              function ${_methodNamePrefix}push${_methodNameSuffix}(${renderArguments([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs,
-              `${portionData.typeWithLocation} ${portionData.name}`
-            ])}) internal {
-                ${_keyTupleDefinition}
-                ${_store}.pushToDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.encoded});
+              function ${p}push${u}(${S([h,n,r,`${o.typeWithLocation} ${o.name}`])}) internal {
+                ${s}
+                ${f}.pushToDynamicField(_tableId, _keyTuple, ${c}, ${o.encoded});
               }
-            `
-          )
-        );
-        result += renderWithFieldSuffix(
-          options.withSuffixlessFieldMethods,
-          field.name,
-          (_methodNameSuffix) => renderWithStore(
-            storeArgument,
-            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+            `)),i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
               /**
-               * @notice Pop ${portionData.title} from ${field.name}${_commentSuffix}.
+               * @notice Pop ${o.title} from ${d.name}${m}.
                */
-              function ${_methodNamePrefix}pop${_methodNameSuffix}(${renderArguments([
-              _typedStore,
-              _typedTableId,
-              _typedKeyArgs
-            ])}) internal {
-                ${_keyTupleDefinition}
-                ${_store}.popFromDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.elementLength});
+              function ${p}pop${u}(${S([h,n,r])}) internal {
+                ${s}
+                ${f}.popFromDynamicField(_tableId, _keyTuple, ${c}, ${o.elementLength});
               }
-            `
-          )
-        );
-      }
-      result += renderWithFieldSuffix(
-        options.withSuffixlessFieldMethods,
-        field.name,
-        (_methodNameSuffix) => renderWithStore(storeArgument, ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => {
-          const externalArguments = renderArguments([
-            _typedStore,
-            _typedTableId,
-            _typedKeyArgs,
-            "uint256 _index",
-            `${portionData.typeWithLocation} ${portionData.name}`
-          ]);
-          const internalArguments = `
+            `))),i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>{let L=S([h,n,r,"uint256 _index",`${o.typeWithLocation} ${o.name}`]),x=`
             _tableId,
             _keyTuple,
-            ${dynamicSchemaIndex},
-            uint40(_index * ${portionData.elementLength}),
+            ${c},
+            uint40(_index * ${o.elementLength}),
             uint40(_encoded.length),
             _encoded 
-          `;
-          return `
+          `;return`
             /**
-             * @notice Update ${portionData.title} of ${field.name}${_commentSuffix} at \`_index\`.
+             * @notice Update ${o.title} of ${d.name}${m} at \`_index\`.
              */
-            function ${_methodNamePrefix}update${_methodNameSuffix}(${externalArguments}) internal {
-              ${_keyTupleDefinition}
+            function ${p}update${u}(${L}) internal {
+              ${s}
               unchecked {
-                bytes memory _encoded = ${portionData.encoded};
-                ${_store}.spliceDynamicData(${internalArguments});
+                bytes memory _encoded = ${o.encoded};
+                ${f}.spliceDynamicData(${x});
               }
             }
-          `;
-        })
-      );
-    }
-  }
-  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
-import {
-  renderArguments as renderArguments2,
-  renderCommonData as renderCommonData2,
-  renderList,
-  renderWithStore as renderWithStore2
-} from "@latticexyz/common/codegen";
-function renderRecordMethods(options) {
-  const { structName, storeArgument } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = renderCommonData2(options);
-  let result = "";
-  if (options.withGetters) {
-    result += renderWithStore2(
-      storeArgument,
-      ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+          `}))}}return i}function E(e){let t;return e.arrayElement?t="EncodeArray.encode":e.isDynamic?t="bytes":t="abi.encodePacked",`${t}(${e.typeUnwrap}(${e.name}))`}function q(e,t){let{staticByteLength:n}=e,r=`Bytes.getBytes${n}(_blob, ${t})`;return W(e,r)}function W(e,t){let{staticByteLength:n,internalTypeId:r}=e,s=n*8,i;if(r.match(/^uint\d{1,3}$/)||r==="address")i=`${r}(${t})`;else if(r.match(/^int\d{1,3}$/))i=`${r}(uint${s}(${t}))`;else if(r.match(/^bytes\d{1,2}$/))i=t;else if(r==="bool")i=`_toBool(uint8(${t}))`;else throw new Error(`Unknown value type id ${r}`);return`${e.typeWrap}(${i})`}function ce(e){if(e.arrayElement){let t="_element",n={...e.arrayElement,arrayElement:void 0,name:t};return{typeWithLocation:e.arrayElement.typeWithLocation,name:t,encoded:E(n),decoded:N(n),title:"an element",elementLength:e.arrayElement.staticByteLength}}else{let t="_slice",n={...e,name:t};return{typeWithLocation:`${e.typeId} memory`,name:t,encoded:E(n),decoded:N(n),title:"a slice",elementLength:1}}}function N(e){let{isDynamic:t,arrayElement:n}=e;return n?`${e.typeWrap}(
+      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${n.internalTypeId}()
+    )`:t?`${e.typeWrap}(${e.internalTypeId}(_blob))`:W(e,`bytes${e.staticByteLength}(_blob)`)}import{renderArguments as g,renderCommonData as V,renderList as Y,renderWithStore as w}from"@latticexyz/common/codegen";function Z(e){let{structName:t,storeArgument:n}=e,{_typedTableId:r,_typedKeyArgs:s,_keyTupleDefinition:i}=V(e),a="";return e.withGetters&&(a+=w(n,({_typedStore:d,_store:y,_commentSuffix:o,_methodNamePrefix:c})=>`
         /**
-         * @notice Get the full data${_commentSuffix}.
+         * @notice Get the full data${o}.
          */
-        function ${_methodNamePrefix}get(${renderArguments2([
-        _typedStore,
-        _typedTableId,
-        _typedKeyArgs
-      ])}) internal view returns (${renderDecodedRecord(options)}) {
-          ${_keyTupleDefinition}
+        function ${c}get(${g([d,r,s])}) internal view returns (${le(e)}) {
+          ${i}
           
           (
             bytes memory _staticData,
             EncodedLengths _encodedLengths,
             bytes memory _dynamicData
-            ) = ${_store}.getRecord(_tableId, _keyTuple, _fieldLayout);
+            ) = ${y}.getRecord(_tableId, _keyTuple, _fieldLayout);
             return decode(_staticData, _encodedLengths, _dynamicData);
           }
-        `
-    );
-  }
-  result += renderWithStore2(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-      const externalArguments = renderArguments2([
-        _typedStore,
-        _typedTableId,
-        _typedKeyArgs,
-        renderArguments2(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`))
-      ]);
-      const internalArguments = "_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-      return `
+        `)),a+=w(n,({_typedStore:d,_store:y,_commentSuffix:o,_methodNamePrefix:c,_useExplicitFieldLayout:l})=>{let u=g([d,r,s,g(e.fields.map(({name:f,typeWithLocation:m})=>`${m} ${f}`))]),h="_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData"+(l?", _fieldLayout":"");return`
         /** 
-         * @notice Set the full data using individual values${_commentSuffix}.
+         * @notice Set the full data using individual values${o}.
          */
-        function ${_methodNamePrefix}set(${externalArguments}) internal {
-          ${renderRecordData(options)}
+        function ${c}set(${u}) internal {
+          ${O(e)}
 
-          ${_keyTupleDefinition}
+          ${i}
 
-          ${_store}.setRecord(${internalArguments});
+          ${y}.setRecord(${h});
         }
-    `;
-    }
-  );
-  if (structName !== void 0) {
-    result += renderWithStore2(
-      storeArgument,
-      ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-        const externalArguments = renderArguments2([
-          _typedStore,
-          _typedTableId,
-          _typedKeyArgs,
-          `${structName} memory _table`
-        ]);
-        const internalArguments = "_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-        return `
+    `}),t!==void 0&&(a+=w(n,({_typedStore:d,_store:y,_commentSuffix:o,_methodNamePrefix:c,_useExplicitFieldLayout:l})=>{let u=g([d,r,s,`${t} memory _table`]),h="_tableId, _keyTuple, _staticData, _encodedLengths, _dynamicData"+(l?", _fieldLayout":"");return`
           /**
-           * @notice Set the full data using the data struct${_commentSuffix}.
+           * @notice Set the full data using the data struct${o}.
            */
-          function ${_methodNamePrefix}set(${externalArguments}) internal {
-            ${renderRecordData(options, "_table.")}
+          function ${c}set(${u}) internal {
+            ${O(e,"_table.")}
 
-            ${_keyTupleDefinition}
+            ${i}
 
-            ${_store}.setRecord(${internalArguments});
+            ${y}.setRecord(${h});
           }
-      `;
-      }
-    );
-  }
-  result += renderDecodeFunctions(options);
-  return result;
-}
-function renderRecordData(options, namePrefix = "") {
-  let result = "";
-  if (options.staticFields.length > 0) {
-    result += `
+      `})),a+=me(e),a}function O(e,t=""){let n="";return e.staticFields.length>0?n+=`
       bytes memory _staticData = encodeStatic(
-        ${renderArguments2(options.staticFields.map(({ name }) => `${namePrefix}${name}`))}
+        ${g(e.staticFields.map(({name:r})=>`${t}${r}`))}
       );
-    `;
-  } else {
-    result += `bytes memory _staticData;`;
-  }
-  if (options.dynamicFields.length > 0) {
-    result += `
+    `:n+="bytes memory _staticData;",e.dynamicFields.length>0?n+=`
       EncodedLengths _encodedLengths = encodeLengths(
-        ${renderArguments2(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
+        ${g(e.dynamicFields.map(({name:r})=>`${t}${r}`))}
       );
       bytes memory _dynamicData = encodeDynamic(
-        ${renderArguments2(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
+        ${g(e.dynamicFields.map(({name:r})=>`${t}${r}`))}
       );
-    `;
-  } else {
-    result += `
+    `:n+=`
       EncodedLengths _encodedLengths;
       bytes memory _dynamicData;
-    `;
-  }
-  return result;
-}
-function renderDeleteRecordMethods(options) {
-  const { storeArgument } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = renderCommonData2(options);
-  return renderWithStore2(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix, _useExplicitFieldLayout }) => {
-      const externalArguments = renderArguments2([_typedStore, _typedTableId, _typedKeyArgs]);
-      const internalArguments = "_tableId, _keyTuple" + (_useExplicitFieldLayout ? ", _fieldLayout" : "");
-      return `
+    `,n}function z(e){let{storeArgument:t}=e,{_typedTableId:n,_typedKeyArgs:r,_keyTupleDefinition:s}=V(e);return w(t,({_typedStore:i,_store:a,_commentSuffix:d,_methodNamePrefix:y,_useExplicitFieldLayout:o})=>{let c=g([i,n,r]),l="_tableId, _keyTuple"+(o?", _fieldLayout":"");return`
         /** 
-         * @notice Delete all data for given keys${_commentSuffix}.
+         * @notice Delete all data for given keys${d}.
          */
-        function ${_methodNamePrefix}deleteRecord(${externalArguments}) internal {
-          ${_keyTupleDefinition}
-          ${_store}.deleteRecord(${internalArguments});
+        function ${y}deleteRecord(${c}) internal {
+          ${s}
+          ${a}.deleteRecord(${l});
         }
-      `;
-    }
-  );
-}
-function renderDecodeFunctions({ structName, fields, staticFields, dynamicFields }) {
-  const renderedDecodedRecord = structName ? `${structName} memory _table` : renderArguments2(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 += `
+      `})}function me({structName:e,fields:t,staticFields:n,dynamicFields:r}){let s=e?`${e} memory _table`:g(t.map(({name:o,typeWithLocation:c})=>`${c} ${o}`)),i=e?"_table.":"",a=n.map(()=>0),d=0;for(let[o,c]of n.entries())a[o]=d,d+=c.staticByteLength;let y="";return n.length>0&&(y+=`
       /**
        * @notice Decode the tightly packed blob of static data using this table's field layout.
        */
-      function decodeStatic(bytes memory _blob) internal pure returns (${renderArguments2(
-      staticFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-    )}) {
-        ${renderList(
-      staticFields,
-      (field, index) => `
-          ${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
-          `
-    )}
+      function decodeStatic(bytes memory _blob) internal pure returns (${g(n.map(({name:o,typeWithLocation:c})=>`${c} ${o}`))}) {
+        ${Y(n,(o,c)=>`
+          ${o.name} = ${q(o,a[c])};
+          `)}
       }
-    `;
-  }
-  if (dynamicFields.length > 0) {
-    result += `
+    `),r.length>0&&(y+=`
       /**
        * @notice Decode the tightly packed blob of dynamic data using the encoded lengths.
        */
-      function decodeDynamic(EncodedLengths _encodedLengths, bytes memory _blob) internal pure returns (${renderArguments2(
-      dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-    )}) {
-        ${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 `
+      function decodeDynamic(EncodedLengths _encodedLengths, bytes memory _blob) internal pure returns (${g(r.map(({name:o,typeWithLocation:c})=>`${c} ${o}`))}) {
+        ${Y(r,(o,c)=>c===0?`
                 uint256 _start;
                 uint256 _end;
                 unchecked {
-                  _end = _encodedLengths.atIndex(${index});
+                  _end = _encodedLengths.atIndex(${c});
                 }
-                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-              `;
-        } else {
-          return `
+                ${o.name} = ${X(o)};
+              `:`
                 _start = _end;
                 unchecked {
-                  _end += _encodedLengths.atIndex(${index});
+                  _end += _encodedLengths.atIndex(${c});
                 }
-                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-              `;
-        }
-      }
-    )}
+                ${o.name} = ${X(o)};
+              `)}
       }
-    `;
-  }
-  result += `
+    `),y+=`
     /**
      * @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." : ""}
+     * ${n.length>0?"@param _staticData Tightly packed static fields.":""}
+    * ${r.length>0?"@param _encodedLengths Encoded lengths of dynamic fields.":""}
+    * ${r.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 += `
-      (${renderArguments2(staticFields.map((field) => `${fieldNamePrefix}${field.name}`))}) = decodeStatic(_staticData);
-    `;
-  }
-  if (dynamicFields.length > 0) {
-    result += `
-      (${renderArguments2(
-      dynamicFields.map((field) => `${fieldNamePrefix}${field.name}`)
-    )}) = decodeDynamic(_encodedLengths, _dynamicData);
-    `;
-  }
-  result += `
+      bytes memory ${n.length>0?"_staticData":""},
+      EncodedLengths ${r.length>0?"_encodedLengths":""},
+      bytes memory ${r.length>0?"_dynamicData":""}
+    ) internal pure returns (${s}) {
+  `,n.length>0&&(y+=`
+      (${g(n.map(o=>`${i}${o.name}`))}) = decodeStatic(_staticData);
+    `),r.length>0&&(y+=`
+      (${g(r.map(o=>`${i}${o.name}`))}) = decodeDynamic(_encodedLengths, _dynamicData);
+    `),y+=`
     }
-  `;
-  return result;
-}
-function renderDecodedRecord({ structName, fields }) {
-  if (structName) {
-    return `${structName} memory _table`;
-  } else {
-    return renderArguments2(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}(
+  `,y}function le({structName:e,fields:t}){return e?`${e} memory _table`:g(t.map(({name:n,typeWithLocation:r})=>`${r} ${n}`))}function X(e){let{typeId:t,arrayElement:n,typeWrap:r}=e;return n?`${r}(
+      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${n.typeId}()
+    )`:`${r}(
+      ${t}(
         SliceLib.getSubslice(_blob, _start, _end).toBytes()
       )
-    )`;
-  }
-}
-
-// ts/codegen/renderTable.ts
-import {
-  renderArguments as renderArguments3,
-  renderCommonData as renderCommonData3,
-  renderList as renderList2,
-  renderImports,
-  renderTableId,
-  renderTypeHelpers,
-  renderWithStore as renderWithStore3,
-  renderedSolidityHeader,
-  renderImportPath
-} from "@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
-import { keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser/internal";
-function renderTable(options) {
-  const {
-    imports,
-    libraryName,
-    structName,
-    staticResourceData,
-    storeImportPath,
-    fields,
-    staticFields,
-    dynamicFields,
-    withRecordMethods,
-    storeArgument,
-    keyTuple
-  } = options;
-  const { _typedTableId, _typedKeyArgs, _keyTupleDefinition } = renderCommonData3(options);
-  return `
-    ${renderedSolidityHeader}
+    )`}import{renderArguments as b,renderCommonData as $e,renderList as P,renderImports as ge,renderTableId as Te,renderTypeHelpers as be,renderWithStore as _e,renderedSolidityHeader as Le,renderImportPath as T}from"@latticexyz/common/codegen";var v={TOTAL_LENGTH:240,NUM_STATIC_FIELDS:232,NUM_DYNAMIC_FIELDS:224};function J(e){return`FieldLayout constant _fieldLayout = FieldLayout.wrap(${fe(e)});`}function fe(e){let t=e.filter(({isDynamic:a})=>!a),n=e.length-t.length,r=0n,s=0;if(e.length>28)throw new Error("FieldLayout: too many fields");if(n>5)throw new Error("FieldLayout: too many dynamic fields");for(let a=0;a<t.length;a++){let{isDynamic:d,staticByteLength:y}=e[a];if(d)throw new Error("FieldLayout: static type after dynamic type");s+=y,r|=BigInt(y)<<BigInt((27-a)*8)}return r|=BigInt(s)<<BigInt(v.TOTAL_LENGTH),r|=BigInt(t.length)<<BigInt(v.NUM_STATIC_FIELDS),r|=BigInt(n)<<BigInt(v.NUM_DYNAMIC_FIELDS),`0x${r.toString(16).padStart(64,"0")}`}import{keySchemaToHex as Se,valueSchemaToHex as De}from"@latticexyz/protocol-parser/internal";function Q(e){let{imports:t,libraryName:n,structName:r,staticResourceData:s,storeImportPath:i,fields:a,staticFields:d,dynamicFields:y,withRecordMethods:o,storeArgument:c,keyTuple:l}=e,{_typedTableId:u,_typedKeyArgs:h,_keyTupleDefinition:f}=$e(e);return`
+    ${Le}
 
     // Import store internals
-    import { IStore } from "${renderImportPath(storeImportPath, "IStore.sol")}";
-    import { StoreSwitch } from "${renderImportPath(storeImportPath, "StoreSwitch.sol")}";
-    import { StoreCore } from "${renderImportPath(storeImportPath, "StoreCore.sol")}";
-    import { Bytes } from "${renderImportPath(storeImportPath, "Bytes.sol")}";
-    import { Memory } from "${renderImportPath(storeImportPath, "Memory.sol")}";
-    import { SliceLib } from "${renderImportPath(storeImportPath, "Slice.sol")}";
-    import { EncodeArray } from "${renderImportPath(storeImportPath, "tightcoder/EncodeArray.sol")}";
-    import { FieldLayout } from "${renderImportPath(storeImportPath, "FieldLayout.sol")}";
-    import { Schema } from "${renderImportPath(storeImportPath, "Schema.sol")}";
-    import { EncodedLengths, EncodedLengthsLib } from "${renderImportPath(storeImportPath, "EncodedLengths.sol")}";
-    import { ResourceId } from "${renderImportPath(storeImportPath, "ResourceId.sol")}";
-
-    ${imports.length > 0 ? `
+    import { IStore } from "${T(i,"IStore.sol")}";
+    import { StoreSwitch } from "${T(i,"StoreSwitch.sol")}";
+    import { StoreCore } from "${T(i,"StoreCore.sol")}";
+    import { Bytes } from "${T(i,"Bytes.sol")}";
+    import { Memory } from "${T(i,"Memory.sol")}";
+    import { SliceLib } from "${T(i,"Slice.sol")}";
+    import { EncodeArray } from "${T(i,"tightcoder/EncodeArray.sol")}";
+    import { FieldLayout } from "${T(i,"FieldLayout.sol")}";
+    import { Schema } from "${T(i,"Schema.sol")}";
+    import { EncodedLengths, EncodedLengthsLib } from "${T(i,"EncodedLengths.sol")}";
+    import { ResourceId } from "${T(i,"ResourceId.sol")}";
+
+    ${t.length>0?`
           // Import user types
-          ${renderImports(imports)}
-          ` : ""}
+          ${ge(t)}
+          `:""}
 
-    ${!structName ? "" : `
-          struct ${structName} {
-            ${renderList2(fields, ({ name, typeId }) => `${typeId} ${name};`)}
+    ${r?`
+          struct ${r} {
+            ${P(a,({name:m,typeId:p})=>`${p} ${m};`)}
           }
-          `}
+          `:""}
 
-    library ${libraryName} {
-      ${staticResourceData ? renderTableId(staticResourceData) : ""}
+    library ${n} {
+      ${s?Te(s):""}
   
-      ${renderFieldLayout(fields)}
+      ${J(a)}
 
-      // Hex-encoded key schema of (${keyTuple.map((field) => field.internalTypeId).join(", ")})
-      Schema constant _keySchema = Schema.wrap(${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(${valueSchemaToHex(
-    Object.fromEntries(fields.map((field) => [field.name, field.internalTypeId]))
-  )});
+      // Hex-encoded key schema of (${l.map(m=>m.internalTypeId).join(", ")})
+      Schema constant _keySchema = Schema.wrap(${Se(Object.fromEntries(l.map(m=>[m.name,m.internalTypeId])))});
+      // Hex-encoded value schema of (${a.map(m=>m.internalTypeId).join(", ")})
+      Schema constant _valueSchema = Schema.wrap(${De(Object.fromEntries(a.map(m=>[m.name,m.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});
-        ${renderList2(keyTuple, (keyElement, index) => `keyNames[${index}] = "${keyElement.name}";`)}
+        keyNames = new string[](${l.length});
+        ${P(l,(m,p)=>`keyNames[${p}] = "${m.name}";`)}
       }
 
       /**
@@ -671,33 +264,30 @@ function renderTable(options) {
        * @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});
-        ${renderList2(fields, (field, index) => `fieldNames[${index}] = "${field.name}";`)}
+        fieldNames = new string[](${a.length});
+        ${P(a,(m,p)=>`fieldNames[${p}] = "${m.name}";`)}
       }
 
-      ${renderWithStore3(
-    storeArgument,
-    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
+      ${_e(c,({_typedStore:m,_store:p,_commentSuffix:L,_methodNamePrefix:x})=>`
           /**
-           * @notice Register the table with its config${_commentSuffix}.
+           * @notice Register the table with its config${L}.
            */
-          function ${_methodNamePrefix}register(${renderArguments3([_typedStore, _typedTableId])}) internal {
-            ${_store}.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+          function ${x}register(${b([m,u])}) internal {
+            ${p}.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
           }
-        `
-  )}
+        `)}
 
-      ${renderFieldMethods(options)}
+      ${K(e)}
 
-      ${withRecordMethods ? renderRecordMethods(options) : ""}
+      ${o?Z(e):""}
 
-      ${renderDeleteRecordMethods(options)}
+      ${z(e)}
 
-      ${renderEncodeStatic(staticFields)}
+      ${Ie(d)}
 
-      ${renderEncodeLengths(dynamicFields)}
+      ${xe(y)}
 
-      ${renderEncodeDynamic(dynamicFields)}
+      ${Ae(y)}
 
       /**
        * @notice Encode all of a record's fields.
@@ -705,10 +295,8 @@ function renderTable(options) {
        * @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(${renderArguments3(
-    options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
-        ${renderRecordData(options)}
+      function encode(${b(e.fields.map(({name:m,typeWithLocation:p})=>`${p} ${m}`))}) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
+        ${O(e)}
 
         return (_staticData, _encodedLengths, _dynamicData);
       }
@@ -716,423 +304,87 @@ function renderTable(options) {
       /**
        * @notice Encode keys as a bytes32 array using this table's field layout.
        */
-      function encodeKeyTuple(${renderArguments3([_typedKeyArgs])}) internal pure returns (bytes32[] memory) {
-        ${_keyTupleDefinition}
+      function encodeKeyTuple(${b([h])}) internal pure returns (bytes32[] memory) {
+        ${f}
         return _keyTuple;
       }
     }
 
-    ${renderTypeHelpers(options)}
-  `;
-}
-function renderEncodeStatic(staticFields) {
-  if (staticFields.length === 0) return "";
-  return `
+    ${be(e)}
+  `}function Ie(e){return e.length===0?"":`
     /**
      * @notice Tightly pack static (fixed length) data using this table's schema.
      * @return The static data, encoded into a sequence of bytes.
      */
-    function encodeStatic(${renderArguments3(
-    staticFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${renderArguments3(staticFields.map(({ name }) => name))});
+    function encodeStatic(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (bytes memory) {
+      return abi.encodePacked(${b(e.map(({name:t})=>t))});
     }
-  `;
-}
-function renderEncodeLengths(dynamicFields) {
-  if (dynamicFields.length === 0) return "";
-  return `
+  `}function xe(e){return e.length===0?"":`
     /**
      * @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(${renderArguments3(
-    dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (EncodedLengths _encodedLengths) {
+    function encodeLengths(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (EncodedLengths _encodedLengths) {
       // Lengths are effectively checked during copy by 2**40 bytes exceeding gas limits
       unchecked {
         _encodedLengths = EncodedLengthsLib.pack(
-          ${renderArguments3(
-    dynamicFields.map(({ name, arrayElement }) => {
-      if (arrayElement) {
-        return `${name}.length * ${arrayElement.staticByteLength}`;
-      } else {
-        return `bytes(${name}).length`;
-      }
-    })
-  )}
+          ${b(e.map(({name:t,arrayElement:n})=>n?`${t}.length * ${n.staticByteLength}`:`bytes(${t}).length`))}
         );
       }
     }
-  `;
-}
-function renderEncodeDynamic(dynamicFields) {
-  if (dynamicFields.length === 0) return "";
-  return `
+  `}function Ae(e){return e.length===0?"":`
     /**
      * @notice Tightly pack dynamic (variable length) data using this table's schema.
      * @return The dynamic data, encoded into a sequence of bytes.
      */
-    function encodeDynamic(${renderArguments3(
-    dynamicFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
-  )}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${renderArguments3(dynamicFields.map((field) => renderEncodeFieldSingle(field)))});
-    }
-  `;
-}
-
-// ts/codegen/renderTypesFromConfig.ts
-import { renderEnums } from "@latticexyz/common/codegen";
-function renderTypesFromConfig(config) {
-  return renderEnums(config.enums);
-}
-
-// ts/codegen/tablegen.ts
-import fs from "node:fs/promises";
-import path4 from "node:path";
-import { formatAndWriteSolidity, renderEnums as renderEnums2 } from "@latticexyz/common/codegen";
-
-// ts/codegen/renderTableIndex.ts
-import { renderImportPath as renderImportPath2, renderList as renderList3, renderedSolidityHeader as renderedSolidityHeader2 } from "@latticexyz/common/codegen";
-import path from "node:path";
-function renderTableIndex(codegenIndexPath, options) {
-  return `
-    ${renderedSolidityHeader2}
-
-    ${renderList3(options, ({ outputPath, tableName, renderOptions: { structName } }) => {
-    const imports = [tableName];
-    if (structName) imports.push(structName);
-    return `import { ${imports.join(", ")} } from "${renderImportPath2("./" + path.relative(path.dirname(codegenIndexPath), outputPath))}";`;
-  })}
-  `;
-}
-
-// ts/codegen/tablegen.ts
-import { uniqueBy } from "@latticexyz/common/utils";
-
-// ts/codegen/getUserTypesFilename.ts
-import path2 from "node:path";
-function getUserTypesFilename({ config }) {
-  return path2.join(config.sourceDirectory, config.codegen.outputDirectory, config.codegen.userTypesFilename);
-}
-
-// ts/codegen/getUserTypes.ts
-import { groupBy } from "@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(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
-import path3 from "path";
-import { SchemaTypeArrayToElement } from "@latticexyz/schema-type/deprecated";
-
-// ts/codegen/userType.ts
-import {
-  AbiTypeToSchemaType,
-  getStaticByteLength,
-  SchemaType,
-  SchemaTypeToAbiType
-} from "@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 AbiTypeToSchemaType) {
-    const schemaType = AbiTypeToSchemaType[abiOrUserType];
-    return {
-      schemaType,
-      renderType: getSchemaTypeInfo(schemaType)
-    };
-  }
-  const staticArray = parseStaticArray(abiOrUserType);
-  if (staticArray) {
-    if (staticArray.elementType in 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 = getStaticByteLength(schemaType);
-  const isDynamic = staticByteLength === 0;
-  const typeId = SchemaTypeToAbiType[schemaType];
-  return {
-    typeId,
-    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
-    enumName: SchemaType[schemaType],
-    staticByteLength,
-    isDynamic,
-    typeWrap: "",
-    typeUnwrap: "",
-    internalTypeId: typeId
-  };
-}
-function getUserTypeInfo(userType) {
-  switch (userType.type) {
-    case "enum": {
-      const schemaType = SchemaType.UINT8;
-      const staticByteLength = getStaticByteLength(schemaType);
-      const isDynamic = staticByteLength === 0;
-      return {
-        schemaType,
-        renderType: {
-          typeId: userType.name,
-          typeWithLocation: userType.name,
-          enumName: SchemaType[schemaType],
-          staticByteLength,
-          isDynamic,
-          typeWrap: userType.name,
-          typeUnwrap: userType.abiType,
-          internalTypeId: userType.abiType
-        }
-      };
-    }
-    case "userType": {
-      const schemaType = AbiTypeToSchemaType[userType.abiType];
-      return {
-        schemaType,
-        renderType: {
-          typeId: userType.name,
-          typeWithLocation: userType.name,
-          enumName: SchemaType[schemaType],
-          staticByteLength: 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 = AbiTypeToSchemaType[internalTypeId];
-  return {
-    schemaType,
-    renderType: {
-      typeId: abiType,
-      typeWithLocation: `${abiType} memory`,
-      enumName: SchemaType[schemaType],
-      staticByteLength: 0,
-      isDynamic: true,
-      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
-      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
-      typeWrappingData: {
-        kind: "staticArray",
-        elementType,
-        staticLength
-      },
-      internalTypeId
+    function encodeDynamic(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (bytes memory) {
+      return abi.encodePacked(${b(e.map(t=>E(t)))});
     }
-  };
-}
-
-// ts/codegen/getTableOptions.ts
-import { getKeySchema, getValueSchema } from "@latticexyz/protocol-parser/internal";
-import { isDefined } from "@latticexyz/common/utils";
-function getTableOptions({
-  tables,
-  rootDir,
-  codegenDir,
-  userTypes,
-  storeImportPath
-}) {
-  const options = tables.map((table) => {
-    const outputPath = path3.join(rootDir, codegenDir, table.codegen.outputDirectory, `${table.label}.sol`);
-    const keySchema = getKeySchema(table);
-    const valueSchema = 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(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(".") ? "./" + path3.relative(path3.dirname(outputPath), path3.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 = 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(".") ? "./" + path3.relative(path3.dirname(outputPath), path3.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
-import debug from "debug";
-async function tablegen({ rootDir, config }) {
-  const userTypes = getUserTypes({ config });
-  if (Object.keys(config.enums).length > 0) {
-    const userTypesFilename = path4.join(rootDir, getUserTypesFilename({ config }));
-    const source = renderEnums2(config.enums);
-    await formatAndWriteSolidity(source, userTypesFilename, "Generated types file with enums");
-  }
-  await Promise.all(
-    Object.values(config.namespaces).map(async (namespace) => {
-      const sourceDir = config.multipleNamespaces ? path4.join(config.sourceDirectory, "namespaces", namespace.label) : config.sourceDirectory;
-      const codegenDir = path4.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 = uniqueBy(
-        tableOptions.map(({ outputPath }) => path4.dirname(outputPath)),
-        (dir) => dir
-      );
-      await Promise.all(tableDirs.map((dir) => fs.rm(dir, { recursive: true, force: true })));
-      await Promise.all(
-        tableOptions.map(async ({ outputPath, renderOptions }) => {
-          const source = renderTable(renderOptions);
-          return await formatAndWriteSolidity(source, outputPath, "Generated table");
-        })
-      );
-      if (config.codegen.indexFilename !== false && tableOptions.length > 0) {
-        const codegenIndexPath = path4.join(rootDir, codegenDir, config.codegen.indexFilename);
-        const source = renderTableIndex(codegenIndexPath, tableOptions);
-        await formatAndWriteSolidity(source, codegenIndexPath, "Generated table index");
-      }
-    })
-  );
-  debug("Generated tables");
-}
-
-// ts/codegen/tightcoder/renderDecodeSlice.ts
-import { renderedSolidityHeader as renderedSolidityHeader3 } from "@latticexyz/common/codegen";
-import { staticAbiTypeToByteLength, staticAbiTypes } from "@latticexyz/schema-type/internal";
+  `}import{renderEnums as Ee}from"@latticexyz/common/codegen";function St(e){return Ee(e.enums)}import je from"node:fs/promises";import k from"node:path";import{formatAndWriteSolidity as G,renderEnums as Ge}from"@latticexyz/common/codegen";import{renderImportPath as Fe,renderList as Re,renderedSolidityHeader as ke}from"@latticexyz/common/codegen";import ee from"node:path";function te(e,t){return`
+    ${ke}
 
-// ts/codegen/tightcoder/renderFunctions.ts
-import { getLeftPaddingBits } from "@latticexyz/common/codegen";
-function renderTightCoderDecode(element) {
-  return `
+    ${Re(t,({outputPath:n,tableName:r,renderOptions:{structName:s}})=>{let i=[r];return s&&i.push(s),`import { ${i.join(", ")} } from "${Fe("./"+ee.relative(ee.dirname(e),n))}";`})}
+  `}import{uniqueBy as He}from"@latticexyz/common/utils";import we from"node:path";function B({config:e}){return we.join(e.sourceDirectory,e.codegen.outputDirectory,e.codegen.userTypesFilename)}import{groupBy as Oe}from"@latticexyz/common/utils";function ne({config:e}){let t=Object.keys(e.enums).map(i=>({type:"enum",name:i,abiType:"uint8",importPath:"./"+B({config:e})})),n=Object.entries(e.userTypes).map(([i,a])=>({type:"userType",name:i,abiType:a.type,importPath:a.filePath})),r=[...t,...n],s=Array.from(Oe(r,i=>i.name).entries()).filter(([,i])=>i.length>1).map(([i])=>i);if(s.length>0)throw new Error(`Found enums and user types sharing the same name: ${s.join(", ")}`);return r}import I from"path";import{SchemaTypeArrayToElement as We}from"@latticexyz/schema-type/deprecated";import{AbiTypeToSchemaType as F,getStaticByteLength as C,SchemaType as R,SchemaTypeToAbiType as ve}from"@latticexyz/schema-type/deprecated";function Be(e){let t=e.match(/^(\w+)\[(\d+)\]$/);return t?{elementType:t[1],staticLength:Number.parseInt(t[2])}:null}function U(e,t){if(e in F){let s=F[e];return{schemaType:s,renderType:j(s)}}let n=Be(e);if(n){if(n.elementType in F)return Ne(e,n.elementType,n.staticLength);throw new Error("Static arrays of user types are not supported")}let r=t.find(s=>s.name===e);if(!r)throw new Error(`User type "${e}" not found`);return Me(r)}function j(e){let t=C(e),n=t===0,r=ve[e];return{typeId:r,typeWithLocation:n?r+" memory":r,enumName:R[e],staticByteLength:t,isDynamic:n,typeWrap:"",typeUnwrap:"",internalTypeId:r}}function Me(e){switch(e.type){case"enum":{let t=R.UINT8,n=C(t),r=n===0;return{schemaType:t,renderType:{typeId:e.name,typeWithLocation:e.name,enumName:R[t],staticByteLength:n,isDynamic:r,typeWrap:e.name,typeUnwrap:e.abiType,internalTypeId:e.abiType}}}case"userType":{let t=F[e.abiType];return{schemaType:t,renderType:{typeId:e.name,typeWithLocation:e.name,enumName:R[t],staticByteLength:C(t),isDynamic:!1,typeWrap:`${e.name}.wrap`,typeUnwrap:`${e.name}.unwrap`,internalTypeId:e.abiType}}}}}function Ne(e,t,n){let r=t+"[]",s=F[r];return{schemaType:s,renderType:{typeId:e,typeWithLocation:`${e} memory`,enumName:R[s],staticByteLength:0,isDynamic:!0,typeWrap:`toStaticArray_${t}_${n}`,typeUnwrap:`fromStaticArray_${t}_${n}`,typeWrappingData:{kind:"staticArray",elementType:t,staticLength:n},internalTypeId:r}}}import{getKeySchema as Pe,getValueSchema as Ce}from"@latticexyz/protocol-parser/internal";import{isDefined as Ue}from"@latticexyz/common/utils";function re({tables:e,rootDir:t,codegenDir:n,userTypes:r,storeImportPath:s}){return e.map(a=>{let d=I.join(t,n,a.codegen.outputDirectory,`${a.label}.sol`),y=Pe(a),o=Ce(a),c=a.codegen.dataStruct,l=c||a.type==="offchainTable"||Object.keys(o).length>1,u=!l&&Object.keys(o).length===1,h=Object.values(a.schema).map($=>r.find(A=>A.name===$.internalType)).filter(Ue).map($=>({symbol:$.name.replace(/\..*$/,""),path:$.importPath.startsWith(".")?"./"+I.relative(I.dirname(d),I.join(t,$.importPath)):$.importPath})),f=Object.entries(y).map(([$,A])=>{let{renderType:M}=U(A.internalType,r);return{...M,name:$,isDynamic:!1}}),m=Object.entries(o).map(([$,A])=>{let{renderType:M,schemaType:de}=U(A.internalType,r),H=We[de];return{...M,arrayElement:H!==void 0?j(H):void 0,name:$}}),p=m.filter(({isDynamic:$})=>!$),L=m.filter(({isDynamic:$})=>$),x=a.codegen.tableIdArgument?void 0:{namespace:a.namespace,name:a.name,offchainOnly:a.type==="offchainTable"};return{outputPath:d,tableName:a.label,renderOptions:{imports:h,libraryName:a.label,structName:c?a.label+"Data":void 0,staticResourceData:x,storeImportPath:s.startsWith(".")?"./"+I.relative(I.dirname(d),I.join(t,s)):s,keyTuple:f,fields:m,staticFields:p,dynamicFields:L,withGetters:a.type==="table",withRecordMethods:l,withDynamicFieldMethods:a.type==="table",withSuffixlessFieldMethods:u,storeArgument:a.codegen.storeArgument}}})}import Ke from"debug";async function zt({rootDir:e,config:t}){let n=ne({config:t});if(Object.keys(t.enums).length>0){let r=k.join(e,B({config:t})),s=Ge(t.enums);await G(s,r,"Generated types file with enums")}await Promise.all(Object.values(t.namespaces).map(async r=>{let s=t.multipleNamespaces?k.join(t.sourceDirectory,"namespaces",r.label):t.sourceDirectory,i=k.join(s,t.codegen.outputDirectory),a=Object.values(r.tables);if(a.length===0)return;let d=re({tables:a,rootDir:e,codegenDir:i,userTypes:n,storeImportPath:t.codegen.storeImportPath}),y=He(d.map(({outputPath:o})=>k.dirname(o)),o=>o);if(await Promise.all(y.map(o=>je.rm(o,{recursive:!0,force:!0}))),await Promise.all(d.map(async({outputPath:o,renderOptions:c})=>{let l=Q(c);return await G(l,o,"Generated table")})),t.codegen.indexFilename!==!1&&d.length>0){let o=k.join(e,i,t.codegen.indexFilename),c=te(o,d);await G(c,o,"Generated table index")}})),Ke("Generated tables")}import{renderedSolidityHeader as qe}from"@latticexyz/common/codegen";import{staticAbiTypeToByteLength as Ye,staticAbiTypes as Xe}from"@latticexyz/schema-type/internal";import{getLeftPaddingBits as oe}from"@latticexyz/common/codegen";function ie(e){return`
     /**
-     * @notice Decodes a slice into an array of ${element.internalTypeId}.
+     * @notice Decodes a slice into an array of ${e.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}.
+     * @return _output The decoded array of ${e.internalTypeId}.
      */
-    function decodeArray_${element.internalTypeId}(
+    function decodeArray_${e.internalTypeId}(
       Slice _input
     ) internal pure returns (
-      ${element.internalTypeId}[] memory _output
+      ${e.internalTypeId}[] memory _output
     ) {
       bytes32[] memory _genericArray = TightCoder.decode(
         _input,
-        ${element.staticByteLength},
-        ${getLeftPaddingBits(element)}
+        ${e.staticByteLength},
+        ${oe(e)}
       );
       assembly {
         _output := _genericArray
       }
     }
-  `;
-}
-function renderTightCoderEncode(element) {
-  return `
+  `}function ae(e){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.
+     * @notice Encodes an array of ${e.internalTypeId} into a tightly packed bytes representation.
+     * @param _input The array of ${e.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) {
+    function encode(${e.internalTypeId}[] memory _input) internal pure returns (bytes memory) {
       bytes32[] memory _genericArray;
       assembly {
         _genericArray := _input
       }
       return TightCoder.encode(
         _genericArray,
-        ${element.staticByteLength},
-        ${getLeftPaddingBits(element)}
+        ${e.staticByteLength},
+        ${oe(e)}
       );
     }
-  `;
-}
-
-// ts/codegen/tightcoder/renderDecodeSlice.ts
-function renderDecodeSlice() {
-  return `
-    ${renderedSolidityHeader3}
+  `}function an(){return`
+    ${qe}
     import { TightCoder } from "./TightCoder.sol";
     import { Slice } from "../Slice.sol";
 
@@ -1143,22 +395,11 @@ function renderDecodeSlice() {
      * @dev This library provides functions for decoding slices into arrays of basic uint types.
      */
     library DecodeSlice {
-      ${staticAbiTypes.map(
-    (staticAbiType) => renderTightCoderDecode({
-      internalTypeId: staticAbiType,
-      staticByteLength: staticAbiTypeToByteLength[staticAbiType]
-    })
-  ).join("\n")}
+      ${Xe.map(e=>ie({internalTypeId:e,staticByteLength:Ye[e]})).join(`
+`)}
     }
-  `;
-}
-
-// ts/codegen/tightcoder/renderEncodeArray.ts
-import { renderedSolidityHeader as renderedSolidityHeader4 } from "@latticexyz/common/codegen";
-import { staticAbiTypeToByteLength as staticAbiTypeToByteLength2, staticAbiTypes as staticAbiTypes2 } from "@latticexyz/schema-type/internal";
-function renderEncodeArray() {
-  return `
-    ${renderedSolidityHeader4}
+  `}import{renderedSolidityHeader as Ve}from"@latticexyz/common/codegen";import{staticAbiTypeToByteLength as Ze,staticAbiTypes as ze}from"@latticexyz/schema-type/internal";function ln(){return`
+    ${Ve}
     import { TightCoder } from "./TightCoder.sol";
 
     /**
@@ -1167,27 +408,16 @@ function renderEncodeArray() {
      * @dev This library provides utilities for encoding arrays into tightly packed bytes representations.
      */
     library EncodeArray {
-      ${staticAbiTypes2.map(
-    (staticAbiType) => renderTightCoderEncode({
-      internalTypeId: staticAbiType,
-      staticByteLength: staticAbiTypeToByteLength2[staticAbiType]
-    })
-  ).join("\n")}
+      ${ze.map(e=>ae({internalTypeId:e,staticByteLength:Ze[e]})).join(`
+`)}
       }
-  `;
-}
-
-// ts/codegen/tightcoder/renderTightCoderAutoTest.ts
-import { renderedSolidityHeader as renderedSolidityHeader5 } from "@latticexyz/common/codegen";
-import { staticAbiTypes as staticAbiTypes3 } from "@latticexyz/schema-type/internal";
-function renderTightCoderAutoTestFunction({ typeId }) {
-  return `
-    function testEncodeDecodeArray_${typeId}(
-      ${typeId} val0,
-      ${typeId} val1,
-      ${typeId} val2
+  `}import{renderedSolidityHeader as Je}from"@latticexyz/common/codegen";import{staticAbiTypes as Qe}from"@latticexyz/schema-type/internal";function et({typeId:e}){return`
+    function testEncodeDecodeArray_${e}(
+      ${e} val0,
+      ${e} val1,
+      ${e} val2
     ) public {
-      ${typeId}[] memory input = new ${typeId}[](3);
+      ${e}[] memory input = new ${e}[](3);
       input[0] = val0;
       input[1] = val1;
       input[2] = val2;
@@ -1195,46 +425,21 @@ function renderTightCoderAutoTestFunction({ typeId }) {
       bytes memory encoded = EncodeArray.encode(input);
       assertEq(encoded, abi.encodePacked(val0, val1, val2));
 
-      ${typeId}[] memory decoded = SliceLib.fromBytes(encoded).decodeArray_${typeId}();
+      ${e}[] memory decoded = SliceLib.fromBytes(encoded).decodeArray_${e}();
       assertEq(decoded.length, 3);
       assertEq(decoded[0], val0);
       assertEq(decoded[1], val1);
       assertEq(decoded[2], val2);
     }
-  `;
-}
-function renderTightCoderAutoTest() {
-  return `
-    ${renderedSolidityHeader5}
+  `}function hn(){return`
+    ${Je}
 
     import { Test } from "forge-std/Test.sol";
     import { EncodeArray } from "../../src/tightcoder/EncodeArray.sol";
     import { SliceLib } from "../../src/Slice.sol";
 
     contract TightCoderAutoTest is Test {
-      ${staticAbiTypes3.map((staticAbiType) => renderTightCoderAutoTestFunction({ typeId: staticAbiType })).join("")}
+      ${Qe.map(e=>et({typeId:e})).join("")}
     }
-  `;
-}
-export {
-  getSchemaTypeInfo,
-  getTableOptions,
-  getUserTypeInfo,
-  renderDecodeSlice,
-  renderDecodeValueType,
-  renderDeleteRecordMethods,
-  renderEncodeArray,
-  renderEncodeFieldSingle,
-  renderFieldMethods,
-  renderRecordData,
-  renderRecordMethods,
-  renderTable,
-  renderTightCoderAutoTest,
-  renderTightCoderAutoTestFunction,
-  renderTightCoderDecode,
-  renderTightCoderEncode,
-  renderTypesFromConfig,
-  resolveAbiOrUserType,
-  tablegen
-};
+  `}export{j as getSchemaTypeInfo,re as getTableOptions,Me as getUserTypeInfo,an as renderDecodeSlice,q as renderDecodeValueType,z as renderDeleteRecordMethods,ln as renderEncodeArray,E as renderEncodeFieldSingle,K as renderFieldMethods,O as renderRecordData,Z as renderRecordMethods,Q as renderTable,hn as renderTightCoderAutoTest,et as renderTightCoderAutoTestFunction,ie as renderTightCoderDecode,ae as renderTightCoderEncode,St as renderTypesFromConfig,U as resolveAbiOrUserType,zt as tablegen};
 //# sourceMappingURL=codegen.js.map