@latticexyz/store 2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77 → 2.2.18

package/dist/codegen.js

@@ -1,262 +1,669 @@
-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})=>`
+// 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 }) => `
             /**
-             * @notice Get ${d.name}${u}.
+             * @notice Get ${field.name}${_commentSuffix}.
              */
-            function ${h}get${o}(${S([c,n,r])}) internal view returns (${y}) {
-              ${s}
-              ${d.isDynamic?`bytes memory _blob = ${l}.getDynamicField(
+            function ${_methodNamePrefix}get${_methodNameSuffix}(${renderArguments([
+            _typedStore,
+            _typedTableId,
+            _typedKeyArgs
+          ])}) internal view returns (${_typedFieldName}) {
+              ${_keyTupleDefinition}
+              ${field.isDynamic ? `bytes memory _blob = ${_store}.getDynamicField(
                       _tableId,
                       _keyTuple,
-                      ${a-e.staticFields.length}
-                    );`:`bytes32 _blob = ${l}.getStaticField(
+                      ${schemaIndex - options.staticFields.length}
+                    );` : `bytes32 _blob = ${_store}.getStaticField(
                       _tableId,
                       _keyTuple,
-                      ${a},
+                      ${schemaIndex},
                       _fieldLayout
                     );`}
-              return ${N(d)};
+              return ${renderDecodeFieldSingle(field)};
             }
-          `))),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`
+          `
+        )
+      );
+    }
+    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 `
           /**
-           * @notice Set ${d.name}${u}.
+           * @notice Set ${field.name}${_commentSuffix}.
            */
-          function ${h}set${o}(${f}) internal {
-            ${s}
-            ${l}.${m}(${L});
+          function ${_methodNamePrefix}set${_methodNameSuffix}(${externalArguments}) internal {
+            ${_keyTupleDefinition}
+            ${_store}.${setFieldMethod}(${internalArguments});
           }
-        `})),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})=>`
+        `;
+      })
+    );
+    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 }) => `
                 /**
-                 * @notice Get the length of ${d.name}${m}.
+                 * @notice Get the length of ${field.name}${_commentSuffix}.
                  */
-                function ${p}length${u}(${S([h,n,r])}) internal view returns (uint256) {
-                  ${s}
-                  uint256 _byteLength = ${f}.getDynamicFieldLength(_tableId, _keyTuple, ${c});
+                function ${_methodNamePrefix}length${_methodNameSuffix}(${renderArguments([
+                _typedStore,
+                _typedTableId,
+                _typedKeyArgs
+              ])}) internal view returns (uint256) {
+                  ${_keyTupleDefinition}
+                  uint256 _byteLength = ${_store}.getDynamicFieldLength(_tableId, _keyTuple, ${dynamicSchemaIndex});
                   unchecked {
-                    return _byteLength / ${o.elementLength};
+                    return _byteLength / ${portionData.elementLength};
                   }
                 }
-              `)),i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
+              `
+            )
+          );
+        }
+        result += renderWithFieldSuffix(
+          options.withSuffixlessFieldMethods,
+          field.name,
+          (_methodNameSuffix) => renderWithStore(
+            storeArgument,
+            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
               /**
-               * @notice Get an item of ${d.name}${m}.
+               * @notice Get an item of ${field.name}${_commentSuffix}.
                * @dev Reverts with Store_IndexOutOfBounds if \`_index\` is out of bounds for the array.
               */
-              function ${p}getItem${u}(${S([h,n,r,"uint256 _index"])}) internal view returns (${o.typeWithLocation}) {
-                ${s}
+              function ${_methodNamePrefix}getItem${_methodNameSuffix}(${renderArguments([
+              _typedStore,
+              _typedTableId,
+              _typedKeyArgs,
+              "uint256 _index"
+            ])}) internal view returns (${portionData.typeWithLocation}) {
+                ${_keyTupleDefinition}
 
-                ${l&&l.kind==="staticArray"&&d.arrayElement?`
-                    uint256 _byteLength = ${f}.getDynamicFieldLength(_tableId, _keyTuple, ${c});
-                    uint256 dynamicLength = _byteLength / ${o.elementLength};
-                    uint256 staticLength = ${l.staticLength};
+                ${// 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 ${W(d.arrayElement,`bytes${d.arrayElement.staticByteLength}(new bytes(0))`)};
-                    }`:""}
+                      return ${renderCastStaticBytesToType(field.arrayElement, `bytes${field.arrayElement.staticByteLength}(new bytes(0))`)};
+                    }` : ``}
 
                 unchecked {
-                  bytes memory _blob = ${f}.getDynamicFieldSlice(
+                  bytes memory _blob = ${_store}.getDynamicFieldSlice(
                     _tableId,
                     _keyTuple,
-                    ${c},
-                    _index * ${o.elementLength},
-                    (_index + 1) * ${o.elementLength}
+                    ${dynamicSchemaIndex},
+                    _index * ${portionData.elementLength},
+                    (_index + 1) * ${portionData.elementLength}
                   );
-                  return ${o.decoded};
+                  return ${portionData.decoded};
                 }
               }
-            `))),(!l||l.kind!=="staticArray")&&(i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
+            `
+          )
+        );
+      }
+      if (!typeWrappingData || typeWrappingData.kind !== "staticArray") {
+        result += renderWithFieldSuffix(
+          options.withSuffixlessFieldMethods,
+          field.name,
+          (_methodNameSuffix) => renderWithStore(
+            storeArgument,
+            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
               /**
-               * @notice Push ${o.title} to ${d.name}${m}.
+               * @notice Push ${portionData.title} to ${field.name}${_commentSuffix}.
                */
-              function ${p}push${u}(${S([h,n,r,`${o.typeWithLocation} ${o.name}`])}) internal {
-                ${s}
-                ${f}.pushToDynamicField(_tableId, _keyTuple, ${c}, ${o.encoded});
+              function ${_methodNamePrefix}push${_methodNameSuffix}(${renderArguments([
+              _typedStore,
+              _typedTableId,
+              _typedKeyArgs,
+              `${portionData.typeWithLocation} ${portionData.name}`
+            ])}) internal {
+                ${_keyTupleDefinition}
+                ${_store}.pushToDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.encoded});
               }
-            `)),i+=_(e.withSuffixlessFieldMethods,d.name,u=>D(t,({_typedStore:h,_store:f,_commentSuffix:m,_methodNamePrefix:p})=>`
+            `
+          )
+        );
+        result += renderWithFieldSuffix(
+          options.withSuffixlessFieldMethods,
+          field.name,
+          (_methodNameSuffix) => renderWithStore(
+            storeArgument,
+            ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
               /**
-               * @notice Pop ${o.title} from ${d.name}${m}.
+               * @notice Pop ${portionData.title} from ${field.name}${_commentSuffix}.
                */
-              function ${p}pop${u}(${S([h,n,r])}) internal {
-                ${s}
-                ${f}.popFromDynamicField(_tableId, _keyTuple, ${c}, ${o.elementLength});
+              function ${_methodNamePrefix}pop${_methodNameSuffix}(${renderArguments([
+              _typedStore,
+              _typedTableId,
+              _typedKeyArgs
+            ])}) internal {
+                ${_keyTupleDefinition}
+                ${_store}.popFromDynamicField(_tableId, _keyTuple, ${dynamicSchemaIndex}, ${portionData.elementLength});
               }
-            `))),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=`
+            `
+          )
+        );
+      }
+      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 = `
             _tableId,
             _keyTuple,
-            ${c},
-            uint40(_index * ${o.elementLength}),
+            ${dynamicSchemaIndex},
+            uint40(_index * ${portionData.elementLength}),
             uint40(_encoded.length),
             _encoded 
-          `;return`
+          `;
+          return `
             /**
-             * @notice Update ${o.title} of ${d.name}${m} at \`_index\`.
+             * @notice Update ${portionData.title} of ${field.name}${_commentSuffix} at \`_index\`.
              */
-            function ${p}update${u}(${L}) internal {
-              ${s}
+            function ${_methodNamePrefix}update${_methodNameSuffix}(${externalArguments}) internal {
+              ${_keyTupleDefinition}
               unchecked {
-                bytes memory _encoded = ${o.encoded};
-                ${f}.spliceDynamicData(${x});
+                bytes memory _encoded = ${portionData.encoded};
+                ${_store}.spliceDynamicData(${internalArguments});
               }
             }
-          `}))}}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})=>`
+          `;
+        })
+      );
+    }
+  }
+  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 }) => `
         /**
-         * @notice Get the full data${o}.
+         * @notice Get the full data${_commentSuffix}.
          */
-        function ${c}get(${g([d,r,s])}) internal view returns (${le(e)}) {
-          ${i}
+        function ${_methodNamePrefix}get(${renderArguments2([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs
+      ])}) internal view returns (${renderDecodedRecord(options)}) {
+          ${_keyTupleDefinition}
           
           (
             bytes memory _staticData,
             EncodedLengths _encodedLengths,
             bytes memory _dynamicData
-            ) = ${y}.getRecord(_tableId, _keyTuple, _fieldLayout);
+            ) = ${_store}.getRecord(_tableId, _keyTuple, _fieldLayout);
             return decode(_staticData, _encodedLengths, _dynamicData);
           }
-        `)),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`
+        `
+    );
+  }
+  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 `
         /** 
-         * @notice Set the full data using individual values${o}.
+         * @notice Set the full data using individual values${_commentSuffix}.
          */
-        function ${c}set(${u}) internal {
-          ${O(e)}
+        function ${_methodNamePrefix}set(${externalArguments}) internal {
+          ${renderRecordData(options)}
 
-          ${i}
+          ${_keyTupleDefinition}
 
-          ${y}.setRecord(${h});
+          ${_store}.setRecord(${internalArguments});
         }
-    `}),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`
+    `;
+    }
+  );
+  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 `
           /**
-           * @notice Set the full data using the data struct${o}.
+           * @notice Set the full data using the data struct${_commentSuffix}.
            */
-          function ${c}set(${u}) internal {
-            ${O(e,"_table.")}
+          function ${_methodNamePrefix}set(${externalArguments}) internal {
+            ${renderRecordData(options, "_table.")}
 
-            ${i}
+            ${_keyTupleDefinition}
 
-            ${y}.setRecord(${h});
+            ${_store}.setRecord(${internalArguments});
           }
-      `})),a+=me(e),a}function O(e,t=""){let n="";return e.staticFields.length>0?n+=`
+      `;
+      }
+    );
+  }
+  result += renderDecodeFunctions(options);
+  return result;
+}
+function renderRecordData(options, namePrefix = "") {
+  let result = "";
+  if (options.staticFields.length > 0) {
+    result += `
       bytes memory _staticData = encodeStatic(
-        ${g(e.staticFields.map(({name:r})=>`${t}${r}`))}
+        ${renderArguments2(options.staticFields.map(({ name }) => `${namePrefix}${name}`))}
       );
-    `:n+="bytes memory _staticData;",e.dynamicFields.length>0?n+=`
+    `;
+  } else {
+    result += `bytes memory _staticData;`;
+  }
+  if (options.dynamicFields.length > 0) {
+    result += `
       EncodedLengths _encodedLengths = encodeLengths(
-        ${g(e.dynamicFields.map(({name:r})=>`${t}${r}`))}
+        ${renderArguments2(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
       );
       bytes memory _dynamicData = encodeDynamic(
-        ${g(e.dynamicFields.map(({name:r})=>`${t}${r}`))}
+        ${renderArguments2(options.dynamicFields.map(({ name }) => `${namePrefix}${name}`))}
       );
-    `:n+=`
+    `;
+  } else {
+    result += `
       EncodedLengths _encodedLengths;
       bytes memory _dynamicData;
-    `,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`
+    `;
+  }
+  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 `
         /** 
-         * @notice Delete all data for given keys${d}.
+         * @notice Delete all data for given keys${_commentSuffix}.
          */
-        function ${y}deleteRecord(${c}) internal {
-          ${s}
-          ${a}.deleteRecord(${l});
+        function ${_methodNamePrefix}deleteRecord(${externalArguments}) internal {
+          ${_keyTupleDefinition}
+          ${_store}.deleteRecord(${internalArguments});
         }
-      `})}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+=`
+      `;
+    }
+  );
+}
+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 += `
       /**
        * @notice Decode the tightly packed blob of static data using this table's field layout.
        */
-      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])};
-          `)}
+      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])};
+          `
+    )}
       }
-    `),r.length>0&&(y+=`
+    `;
+  }
+  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 (${g(r.map(({name:o,typeWithLocation:c})=>`${c} ${o}`))}) {
-        ${Y(r,(o,c)=>c===0?`
+      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 `
                 uint256 _start;
                 uint256 _end;
                 unchecked {
-                  _end = _encodedLengths.atIndex(${c});
+                  _end = _encodedLengths.atIndex(${index});
                 }
-                ${o.name} = ${X(o)};
-              `:`
+                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
+              `;
+        } else {
+          return `
                 _start = _end;
                 unchecked {
-                  _end += _encodedLengths.atIndex(${c});
+                  _end += _encodedLengths.atIndex(${index});
                 }
-                ${o.name} = ${X(o)};
-              `)}
+                ${field.name} = ${renderDecodeDynamicFieldPartial(field)};
+              `;
+        }
+      }
+    )}
       }
-    `),y+=`
+    `;
+  }
+  result += `
     /**
      * @notice Decode the tightly packed blobs using this table's field layout.
-     * ${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.":""}
+     * ${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 ${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+=`
+      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 += `
     }
-  `,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}(
+  `;
+  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}(
         SliceLib.getSubslice(_blob, _start, _end).toBytes()
       )
-    )`}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}
+    )`;
+  }
+}
+
+// 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 store internals
-    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 { 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 user types
-          ${ge(t)}
-          `:""}
+          ${renderImports(imports)}
+          ` : ""}
 
-    ${r?`
-          struct ${r} {
-            ${P(a,({name:m,typeId:p})=>`${p} ${m};`)}
+    ${!structName ? "" : `
+          struct ${structName} {
+            ${renderList2(fields, ({ name, typeId }) => `${typeId} ${name};`)}
           }
-          `:""}
+          `}
 
-    library ${n} {
-      ${s?Te(s):""}
+    library ${libraryName} {
+      ${staticResourceData ? renderTableId(staticResourceData) : ""}
   
-      ${J(a)}
+      ${renderFieldLayout(fields)}
 
-      // 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])))});
+      // 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]))
+  )});
 
       /**
        * @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[](${l.length});
-        ${P(l,(m,p)=>`keyNames[${p}] = "${m.name}";`)}
+        keyNames = new string[](${keyTuple.length});
+        ${renderList2(keyTuple, (keyElement, index) => `keyNames[${index}] = "${keyElement.name}";`)}
       }
 
       /**
@@ -264,30 +671,33 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
        * @return fieldNames An array of strings with the names of value fields.
        */
       function getFieldNames() internal pure returns (string[] memory fieldNames) {
-        fieldNames = new string[](${a.length});
-        ${P(a,(m,p)=>`fieldNames[${p}] = "${m.name}";`)}
+        fieldNames = new string[](${fields.length});
+        ${renderList2(fields, (field, index) => `fieldNames[${index}] = "${field.name}";`)}
       }
 
-      ${_e(c,({_typedStore:m,_store:p,_commentSuffix:L,_methodNamePrefix:x})=>`
+      ${renderWithStore3(
+    storeArgument,
+    ({ _typedStore, _store, _commentSuffix, _methodNamePrefix }) => `
           /**
-           * @notice Register the table with its config${L}.
+           * @notice Register the table with its config${_commentSuffix}.
            */
-          function ${x}register(${b([m,u])}) internal {
-            ${p}.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+          function ${_methodNamePrefix}register(${renderArguments3([_typedStore, _typedTableId])}) internal {
+            ${_store}.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
           }
-        `)}
+        `
+  )}
 
-      ${K(e)}
+      ${renderFieldMethods(options)}
 
-      ${o?Z(e):""}
+      ${withRecordMethods ? renderRecordMethods(options) : ""}
 
-      ${z(e)}
+      ${renderDeleteRecordMethods(options)}
 
-      ${Ie(d)}
+      ${renderEncodeStatic(staticFields)}
 
-      ${xe(y)}
+      ${renderEncodeLengths(dynamicFields)}
 
-      ${Ae(y)}
+      ${renderEncodeDynamic(dynamicFields)}
 
       /**
        * @notice Encode all of a record's fields.
@@ -295,8 +705,10 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
        * @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(${b(e.fields.map(({name:m,typeWithLocation:p})=>`${p} ${m}`))}) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
-        ${O(e)}
+      function encode(${renderArguments3(
+    options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
+  )}) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
+        ${renderRecordData(options)}
 
         return (_staticData, _encodedLengths, _dynamicData);
       }
@@ -304,87 +716,423 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
       /**
        * @notice Encode keys as a bytes32 array using this table's field layout.
        */
-      function encodeKeyTuple(${b([h])}) internal pure returns (bytes32[] memory) {
-        ${f}
+      function encodeKeyTuple(${renderArguments3([_typedKeyArgs])}) internal pure returns (bytes32[] memory) {
+        ${_keyTupleDefinition}
         return _keyTuple;
       }
     }
 
-    ${be(e)}
-  `}function Ie(e){return e.length===0?"":`
+    ${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(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${b(e.map(({name:t})=>t))});
+    function encodeStatic(${renderArguments3(
+    staticFields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
+  )}) internal pure returns (bytes memory) {
+      return abi.encodePacked(${renderArguments3(staticFields.map(({ name }) => name))});
     }
-  `}function xe(e){return e.length===0?"":`
+  `;
+}
+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(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (EncodedLengths _encodedLengths) {
+    function encodeLengths(${renderArguments3(
+    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(
-          ${b(e.map(({name:t,arrayElement:n})=>n?`${t}.length * ${n.staticByteLength}`:`bytes(${t}).length`))}
+          ${renderArguments3(
+    dynamicFields.map(({ name, arrayElement }) => {
+      if (arrayElement) {
+        return `${name}.length * ${arrayElement.staticByteLength}`;
+      } else {
+        return `bytes(${name}).length`;
+      }
+    })
+  )}
         );
       }
     }
-  `}function Ae(e){return e.length===0?"":`
+  `;
+}
+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(${b(e.map(({name:t,typeWithLocation:n})=>`${n} ${t}`))}) internal pure returns (bytes memory) {
-      return abi.encodePacked(${b(e.map(t=>E(t)))});
+    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
     }
-  `}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/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";
 
-    ${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`
+// ts/codegen/tightcoder/renderFunctions.ts
+import { getLeftPaddingBits } from "@latticexyz/common/codegen";
+function renderTightCoderDecode(element) {
+  return `
     /**
-     * @notice Decodes a slice into an array of ${e.internalTypeId}.
+     * @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 ${e.internalTypeId}.
+     * @return _output The decoded array of ${element.internalTypeId}.
      */
-    function decodeArray_${e.internalTypeId}(
+    function decodeArray_${element.internalTypeId}(
       Slice _input
     ) internal pure returns (
-      ${e.internalTypeId}[] memory _output
+      ${element.internalTypeId}[] memory _output
     ) {
       bytes32[] memory _genericArray = TightCoder.decode(
         _input,
-        ${e.staticByteLength},
-        ${oe(e)}
+        ${element.staticByteLength},
+        ${getLeftPaddingBits(element)}
       );
       assembly {
         _output := _genericArray
       }
     }
-  `}function ae(e){return`
+  `;
+}
+function renderTightCoderEncode(element) {
+  return `
 
     /**
-     * @notice Encodes an array of ${e.internalTypeId} into a tightly packed bytes representation.
-     * @param _input The array of ${e.internalTypeId} values to be encoded.
+     * @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(${e.internalTypeId}[] memory _input) internal pure returns (bytes memory) {
+    function encode(${element.internalTypeId}[] memory _input) internal pure returns (bytes memory) {
       bytes32[] memory _genericArray;
       assembly {
         _genericArray := _input
       }
       return TightCoder.encode(
         _genericArray,
-        ${e.staticByteLength},
-        ${oe(e)}
+        ${element.staticByteLength},
+        ${getLeftPaddingBits(element)}
       );
     }
-  `}function an(){return`
-    ${qe}
+  `;
+}
+
+// ts/codegen/tightcoder/renderDecodeSlice.ts
+function renderDecodeSlice() {
+  return `
+    ${renderedSolidityHeader3}
     import { TightCoder } from "./TightCoder.sol";
     import { Slice } from "../Slice.sol";
 
@@ -395,11 +1143,22 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
      * @dev This library provides functions for decoding slices into arrays of basic uint types.
      */
     library DecodeSlice {
-      ${Xe.map(e=>ie({internalTypeId:e,staticByteLength:Ye[e]})).join(`
-`)}
+      ${staticAbiTypes.map(
+    (staticAbiType) => renderTightCoderDecode({
+      internalTypeId: staticAbiType,
+      staticByteLength: staticAbiTypeToByteLength[staticAbiType]
+    })
+  ).join("\n")}
     }
-  `}import{renderedSolidityHeader as Ve}from"@latticexyz/common/codegen";import{staticAbiTypeToByteLength as Ze,staticAbiTypes as ze}from"@latticexyz/schema-type/internal";function ln(){return`
-    ${Ve}
+  `;
+}
+
+// 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 { TightCoder } from "./TightCoder.sol";
 
     /**
@@ -408,16 +1167,27 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
      * @dev This library provides utilities for encoding arrays into tightly packed bytes representations.
      */
     library EncodeArray {
-      ${ze.map(e=>ae({internalTypeId:e,staticByteLength:Ze[e]})).join(`
-`)}
+      ${staticAbiTypes2.map(
+    (staticAbiType) => renderTightCoderEncode({
+      internalTypeId: staticAbiType,
+      staticByteLength: staticAbiTypeToByteLength2[staticAbiType]
+    })
+  ).join("\n")}
       }
-  `}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
+  `;
+}
+
+// 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
     ) public {
-      ${e}[] memory input = new ${e}[](3);
+      ${typeId}[] memory input = new ${typeId}[](3);
       input[0] = val0;
       input[1] = val1;
       input[2] = val2;
@@ -425,21 +1195,46 @@ import{renderArguments as S,renderCommonData as se,renderWithFieldSuffix as _,re
       bytes memory encoded = EncodeArray.encode(input);
       assertEq(encoded, abi.encodePacked(val0, val1, val2));
 
-      ${e}[] memory decoded = SliceLib.fromBytes(encoded).decodeArray_${e}();
+      ${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 hn(){return`
-    ${Je}
+  `;
+}
+function renderTightCoderAutoTest() {
+  return `
+    ${renderedSolidityHeader5}
 
     import { Test } from "forge-std/Test.sol";
     import { EncodeArray } from "../../src/tightcoder/EncodeArray.sol";
     import { SliceLib } from "../../src/Slice.sol";
 
     contract TightCoderAutoTest is Test {
-      ${Qe.map(e=>et({typeId:e})).join("")}
+      ${staticAbiTypes3.map((staticAbiType) => renderTightCoderAutoTestFunction({ typeId: staticAbiType })).join("")}
     }
-  `}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};
+  `;
+}
+export {
+  getSchemaTypeInfo,
+  getTableOptions,
+  getUserTypeInfo,
+  renderDecodeSlice,
+  renderDecodeValueType,
+  renderDeleteRecordMethods,
+  renderEncodeArray,
+  renderEncodeFieldSingle,
+  renderFieldMethods,
+  renderRecordData,
+  renderRecordMethods,
+  renderTable,
+  renderTightCoderAutoTest,
+  renderTightCoderAutoTestFunction,
+  renderTightCoderDecode,
+  renderTightCoderEncode,
+  renderTypesFromConfig,
+  resolveAbiOrUserType,
+  tablegen
+};
 //# sourceMappingURL=codegen.js.map