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

package/dist/internal.cjs

@@ -1,756 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ts/exports/internal.ts
-var internal_exports = {};
-__export(internal_exports, {
-  AbiTypeScope: () => AbiTypeScope,
-  CODEGEN_DEFAULTS: () => CODEGEN_DEFAULTS,
-  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
-  NoStaticKeyFieldError: () => NoStaticKeyFieldError,
-  Scope: () => Scope,
-  TABLE_CODEGEN_DEFAULTS: () => TABLE_CODEGEN_DEFAULTS,
-  TABLE_DEFAULTS: () => TABLE_DEFAULTS,
-  TABLE_DEPLOY_DEFAULTS: () => TABLE_DEPLOY_DEFAULTS,
-  defineNamespaces: () => defineNamespaces,
-  defineSchema: () => defineSchema,
-  defineStore: () => defineStore,
-  defineTable: () => defineTable,
-  defineTableShorthand: () => defineTableShorthand,
-  defineTables: () => defineTables,
-  emptyRecord: () => emptyRecord,
-  expandTableShorthand: () => expandTableShorthand,
-  extendScope: () => extendScope,
-  extendedScope: () => extendedScope,
-  extractInternalType: () => extractInternalType,
-  flattenNamespacedTables: () => flattenNamespacedTables,
-  flattenStoreLogs: () => flattenStoreLogs,
-  get: () => get,
-  getPath: () => getPath,
-  getRecord: () => getRecord,
-  getStaticDataLocation: () => getStaticDataLocation,
-  getStoreLogs: () => getStoreLogs,
-  hasOwnKey: () => hasOwnKey,
-  isObject: () => isObject,
-  isSchemaInput: () => isSchemaInput,
-  isTableShorthandInput: () => isTableShorthandInput,
-  isUserTypes: () => isUserTypes,
-  isValidPrimaryKey: () => isValidPrimaryKey,
-  logToRecord: () => logToRecord,
-  mapEnums: () => mapEnums,
-  mergeIfUndefined: () => mergeIfUndefined,
-  resolveCodegen: () => resolveCodegen,
-  resolveEnums: () => resolveEnums,
-  resolveNamespace: () => resolveNamespace,
-  resolveNamespaces: () => resolveNamespaces,
-  resolveSchema: () => resolveSchema,
-  resolveStore: () => resolveStore,
-  resolveTable: () => resolveTable,
-  resolveTableCodegen: () => resolveTableCodegen,
-  resolveTables: () => resolveTables,
-  scopeWithEnums: () => scopeWithEnums,
-  scopeWithUserTypes: () => scopeWithUserTypes,
-  validateNamespace: () => validateNamespace,
-  validateNamespaces: () => validateNamespaces,
-  validateSchema: () => validateSchema,
-  validateStore: () => validateStore,
-  validateTable: () => validateTable,
-  validateTableShorthand: () => validateTableShorthand,
-  validateTables: () => validateTables,
-  validateUserTypes: () => validateUserTypes
-});
-module.exports = __toCommonJS(internal_exports);
-
-// ts/common.ts
-var emptyRecord = {
-  staticData: "0x",
-  encodedLengths: "0x",
-  dynamicData: "0x"
-};
-
-// ts/getStoreLogs.ts
-var import_viem = require("viem");
-
-// ts/storeEventsAbi.ts
-var import_abitype = require("abitype");
-
-// ts/storeEvents.ts
-var storeSetRecordEvent = "event Store_SetRecord(bytes32 indexed tableId, bytes32[] keyTuple, bytes staticData, bytes32 encodedLengths, bytes dynamicData)";
-var storeSpliceStaticDataEvent = "event Store_SpliceStaticData(bytes32 indexed tableId, bytes32[] keyTuple, uint48 start, bytes data)";
-var storeSpliceDynamicDataEvent = "event Store_SpliceDynamicData(bytes32 indexed tableId, bytes32[] keyTuple, uint8 dynamicFieldIndex, uint48 start, uint40 deleteCount, bytes32 encodedLengths, bytes data)";
-var storeDeleteRecordEvent = "event Store_DeleteRecord(bytes32 indexed tableId, bytes32[] keyTuple)";
-var storeEvents = [
-  storeSetRecordEvent,
-  storeSpliceStaticDataEvent,
-  storeSpliceDynamicDataEvent,
-  storeDeleteRecordEvent
-];
-
-// ts/storeEventsAbi.ts
-var storeEventsAbi = (0, import_abitype.parseAbi)(storeEvents);
-
-// ts/debug.ts
-var import_debug = __toESM(require("debug"), 1);
-var debug = (0, import_debug.default)("mud:store");
-debug.log = console.debug.bind(console);
-var error = (0, import_debug.default)("mud:store");
-error.log = console.error.bind(console);
-
-// ts/getStoreLogs.ts
-var import_common = require("@latticexyz/common");
-async function getStoreLogs(client, { address, tableId, fromBlock, toBlock } = {}) {
-  const topics = [storeEventsAbi.map(import_viem.toEventSelector), tableId ?? null];
-  const tableIds = tableId ? Array.isArray(tableId) ? tableId : [tableId] : [];
-  const addresses = address ? Array.isArray(address) ? address : [address] : [];
-  debug(
-    `getting store logs for ${tableIds.length ? tableIds.map(import_common.hexToResource).map(import_common.resourceToLabel).join(", ") : "all tables"} at ${addresses.length ? addresses.join(", ") : "any address"}`
-  );
-  const logs = await client.request({
-    method: "eth_getLogs",
-    params: [
-      {
-        address,
-        topics,
-        fromBlock: typeof fromBlock === "bigint" ? (0, import_viem.numberToHex)(fromBlock) : fromBlock,
-        toBlock: typeof toBlock === "bigint" ? (0, import_viem.numberToHex)(toBlock) : toBlock
-      }
-    ]
-  });
-  const formattedLogs = logs.map((log) => (0, import_viem.formatLog)(log));
-  return (0, import_viem.parseEventLogs)({
-    abi: storeEventsAbi,
-    args: { tableId },
-    logs: formattedLogs,
-    strict: true
-  });
-}
-
-// ts/flattenStoreLogs.ts
-var import_viem2 = require("viem");
-var import_common3 = require("@latticexyz/common");
-function getKey(log) {
-  return [log.address, log.args.tableId, log.args.keyTuple.join(",")].join(":");
-}
-function flattenStoreLogs(logs) {
-  const sortedLogs = logs.slice().sort(import_common3.logSort);
-  const records = /* @__PURE__ */ new Map();
-  for (const log of sortedLogs) {
-    const key = getKey(log);
-    if (log.eventName === "Store_SetRecord") {
-      records.delete(key);
-      records.set(key, log);
-    } else if (log.eventName === "Store_SpliceStaticData") {
-      const previousRecord = records.get(key);
-      const { staticData, encodedLengths, dynamicData } = previousRecord?.args ?? emptyRecord;
-      const nextRecord = {
-        ...log,
-        eventName: "Store_SetRecord",
-        args: {
-          tableId: log.args.tableId,
-          keyTuple: log.args.keyTuple,
-          staticData: (0, import_common3.spliceHex)(staticData, log.args.start, (0, import_viem2.size)(log.args.data), log.args.data),
-          encodedLengths,
-          dynamicData
-        }
-      };
-      records.delete(key);
-      records.set(key, nextRecord);
-    } else if (log.eventName === "Store_SpliceDynamicData") {
-      const previousRecord = records.get(key);
-      const { staticData, dynamicData } = previousRecord?.args ?? emptyRecord;
-      const nextRecord = {
-        ...log,
-        eventName: "Store_SetRecord",
-        args: {
-          tableId: log.args.tableId,
-          keyTuple: log.args.keyTuple,
-          staticData,
-          encodedLengths: log.args.encodedLengths,
-          dynamicData: (0, import_common3.spliceHex)(dynamicData, log.args.start, log.args.deleteCount, log.args.data)
-        }
-      };
-      records.delete(key);
-      records.set(key, nextRecord);
-    } else if (log.eventName === "Store_DeleteRecord") {
-      records.delete(key);
-    }
-  }
-  return Array.from(records.values());
-}
-
-// ts/logToRecord.ts
-var import_internal = require("@latticexyz/protocol-parser/internal");
-function logToRecord({
-  table,
-  log
-}) {
-  const keySchema = (0, import_internal.getSchemaTypes)((0, import_internal.getKeySchema)(table));
-  const valueSchema = (0, import_internal.getSchemaTypes)((0, import_internal.getValueSchema)(table));
-  const key = (0, import_internal.decodeKey)(keySchema, log.args.keyTuple);
-  const value = (0, import_internal.decodeValueArgs)(valueSchema, log.args);
-  return { ...key, ...value };
-}
-
-// ts/getRecord.ts
-var import_internal2 = require("@latticexyz/protocol-parser/internal");
-var import_actions = require("viem/actions");
-var import_utils = require("viem/utils");
-async function getRecord(client, { address, table, key, blockTag }) {
-  const [staticData, encodedLengths, dynamicData] = await (0, import_utils.getAction)(
-    client,
-    import_actions.readContract,
-    "readContract"
-  )({
-    address,
-    abi,
-    functionName: "getRecord",
-    args: [table.tableId, (0, import_internal2.getKeyTuple)(table, key)],
-    blockTag
-  });
-  return {
-    ...key,
-    ...(0, import_internal2.decodeValueArgs)((0, import_internal2.getSchemaTypes)((0, import_internal2.getValueSchema)(table)), { staticData, encodedLengths, dynamicData })
-  };
-}
-var abi = [
-  {
-    type: "function",
-    name: "getRecord",
-    inputs: [
-      {
-        name: "tableId",
-        type: "bytes32",
-        internalType: "ResourceId"
-      },
-      {
-        name: "keyTuple",
-        type: "bytes32[]",
-        internalType: "bytes32[]"
-      }
-    ],
-    outputs: [
-      {
-        name: "staticData",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "encodedLengths",
-        type: "bytes32",
-        internalType: "EncodedLengths"
-      },
-      {
-        name: "dynamicData",
-        type: "bytes",
-        internalType: "bytes"
-      }
-    ],
-    stateMutability: "view"
-  }
-];
-
-// ts/getStaticDataLocation.ts
-var import_viem3 = require("viem");
-var SLOT = (0, import_viem3.hexToBigInt)((0, import_viem3.keccak256)((0, import_viem3.toBytes)("mud.store")));
-function getStaticDataLocation(tableId, keyTuple) {
-  return (0, import_viem3.numberToHex)(SLOT ^ (0, import_viem3.hexToBigInt)((0, import_viem3.keccak256)((0, import_viem3.concatHex)([tableId, ...keyTuple]))), { size: 32 });
-}
-
-// ts/config/v2/defaults.ts
-var CODEGEN_DEFAULTS = {
-  storeImportPath: "@latticexyz/store/src",
-  userTypesFilename: "common.sol",
-  outputDirectory: "codegen",
-  indexFilename: "index.sol"
-};
-var TABLE_CODEGEN_DEFAULTS = {
-  outputDirectory: "tables",
-  tableIdArgument: false,
-  storeArgument: false
-};
-var TABLE_DEPLOY_DEFAULTS = {
-  disabled: false
-};
-var TABLE_DEFAULTS = {
-  namespaceLabel: "",
-  type: "table"
-};
-var CONFIG_DEFAULTS = {
-  sourceDirectory: "src",
-  namespace: ""
-};
-
-// ts/config/v2/generics.ts
-function get(input, key) {
-  return typeof input === "object" && input != null && hasOwnKey(input, key) ? input[key] : void 0;
-}
-function getPath(input, path) {
-  return path.length ? getPath(get(input, path[0]), path.slice(1)) : input;
-}
-function hasOwnKey(object, key) {
-  return typeof object === "object" && object !== null && object.hasOwnProperty(key);
-}
-function isObject(input) {
-  return input != null && typeof input === "object";
-}
-function mergeIfUndefined(base, defaults) {
-  const keys = [.../* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(defaults)])];
-  return Object.fromEntries(
-    keys.map((key) => [
-      key,
-      typeof base[key] === "undefined" ? defaults[key] : base[key]
-    ])
-  );
-}
-
-// ts/config/v2/codegen.ts
-function resolveCodegen(codegen) {
-  return isObject(codegen) ? mergeIfUndefined(codegen, CODEGEN_DEFAULTS) : CODEGEN_DEFAULTS;
-}
-
-// ts/config/v2/enums.ts
-var import_util = require("@ark/util");
-
-// ts/config/v2/scope.ts
-var import_internal3 = require("@latticexyz/schema-type/internal");
-var Scope = { types: {} };
-var AbiTypeScope = {
-  types: Object.fromEntries(import_internal3.schemaAbiTypes.map((abiType) => [abiType, abiType]))
-};
-function extendScope(scope, additionalTypes) {
-  return {
-    types: {
-      ...scope.types,
-      ...additionalTypes
-    }
-  };
-}
-
-// ts/config/v2/enums.ts
-function isEnums(enums) {
-  return typeof enums === "object" && enums != null && Object.values(enums).every((item) => Array.isArray(item) && item.every((element) => typeof element === "string"));
-}
-function scopeWithEnums(enums, scope = AbiTypeScope) {
-  if (isEnums(enums)) {
-    const enumScope = Object.fromEntries(Object.keys(enums).map((key) => [key, "uint8"]));
-    return extendScope(scope, enumScope);
-  }
-  return scope;
-}
-function resolveEnums(enums) {
-  return enums;
-}
-function mapEnums(enums) {
-  return (0, import_util.flatMorph)(enums, (enumName, enumElements) => [
-    enumName,
-    (0, import_util.flatMorph)(enumElements, (enumIndex, enumElement) => [enumElement, enumIndex])
-  ]);
-}
-
-// ts/config/v2/flattenNamespacedTables.ts
-function flattenNamespacedTables(config) {
-  return Object.fromEntries(
-    Object.entries(config.namespaces).flatMap(
-      ([namespaceLabel, namespace]) => Object.entries(namespace.tables).map(([tableLabel, table]) => [
-        namespaceLabel === "" ? tableLabel : `${namespaceLabel}__${tableLabel}`,
-        table
-      ])
-    )
-  );
-}
-
-// ts/config/v2/namespace.ts
-var import_util2 = require("@ark/util");
-
-// ts/config/v2/table.ts
-var import_internal5 = require("@latticexyz/schema-type/internal");
-
-// ts/config/v2/schema.ts
-var import_internal4 = require("@latticexyz/schema-type/internal");
-function validateSchema(schema, scope = AbiTypeScope) {
-  if (!isObject(schema)) {
-    throw new Error(`Expected schema, received ${JSON.stringify(schema)}`);
-  }
-  for (const internalType of Object.values(schema)) {
-    if ((0, import_internal4.isFixedArrayAbiType)(internalType)) continue;
-    if (hasOwnKey(scope.types, internalType)) continue;
-    throw new Error(`"${String(internalType)}" is not a valid type in this scope.`);
-  }
-}
-function resolveSchema(schema, scope = AbiTypeScope) {
-  return Object.fromEntries(
-    Object.entries(schema).map(([key, internalType]) => [
-      key,
-      {
-        type: (0, import_internal4.isFixedArrayAbiType)(internalType) ? (0, import_internal4.fixedArrayToArray)(internalType) : scope.types[internalType],
-        internalType
-      }
-    ])
-  );
-}
-function defineSchema(schema, scope = AbiTypeScope) {
-  validateSchema(schema, scope);
-  return resolveSchema(schema, scope);
-}
-function isSchemaInput(input, scope = AbiTypeScope) {
-  return typeof input === "object" && input != null && Object.values(input).every((fieldType) => (0, import_internal4.isFixedArrayAbiType)(fieldType) || hasOwnKey(scope.types, fieldType));
-}
-
-// ts/config/v2/table.ts
-var import_common4 = require("@latticexyz/common");
-function getValidKeys(schema, scope = AbiTypeScope) {
-  return Object.entries(schema).filter(([, internalType]) => hasOwnKey(scope.types, internalType) && (0, import_internal5.isStaticAbiType)(scope.types[internalType])).map(([key]) => key);
-}
-function isValidPrimaryKey(key, schema, scope = AbiTypeScope) {
-  return Array.isArray(key) && key.every(
-    (key2) => hasOwnKey(schema, key2) && hasOwnKey(scope.types, schema[key2]) && (0, import_internal5.isStaticAbiType)(scope.types[schema[key2]])
-  );
-}
-function validateTable(input, scope = AbiTypeScope, options = { inStoreContext: false }) {
-  if (typeof input !== "object" || input == null) {
-    throw new Error(`Expected full table config, got \`${JSON.stringify(input)}\``);
-  }
-  if (!hasOwnKey(input, "schema")) {
-    throw new Error("Missing schema input");
-  }
-  validateSchema(input.schema, scope);
-  if (!hasOwnKey(input, "key") || !isValidPrimaryKey(input["key"], input["schema"], scope)) {
-    throw new Error(
-      `Invalid key. Expected \`(${getValidKeys(input["schema"], scope).map((item) => `"${String(item)}"`).join(" | ")})[]\`, received \`${hasOwnKey(input, "key") && Array.isArray(input.key) ? `[${input.key.map((item) => `"${item}"`).join(", ")}]` : String(get(input, "key"))}\``
-    );
-  }
-  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
-    throw new Error(`Table \`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
-  }
-  if (hasOwnKey(input, "namespaceLabel") && typeof input.namespaceLabel === "string" && (!hasOwnKey(input, "namespace") || typeof input.namespace !== "string") && input.namespaceLabel.length > 14) {
-    throw new Error(
-      `Table \`namespace\` defaults to \`namespaceLabel\`, but must fit into a \`bytes14\` and "${input.namespaceLabel}" is too long. Provide explicit \`namespace\` override.`
-    );
-  }
-  if (hasOwnKey(input, "name") && typeof input.name === "string" && input.name.length > 16) {
-    throw new Error(`Table \`name\` must fit into a \`bytes16\`, but "${input.name}" is too long.`);
-  }
-  if (options.inStoreContext && (hasOwnKey(input, "label") || hasOwnKey(input, "namespaceLabel") || hasOwnKey(input, "namespace"))) {
-    throw new Error(
-      "Overrides of `label`, `namespaceLabel`, and `namespace` are not allowed for tables in this context."
-    );
-  }
-}
-function resolveTableCodegen(input) {
-  const options = input.codegen;
-  return {
-    outputDirectory: get(options, "outputDirectory") ?? TABLE_CODEGEN_DEFAULTS.outputDirectory,
-    tableIdArgument: get(options, "tableIdArgument") ?? TABLE_CODEGEN_DEFAULTS.tableIdArgument,
-    storeArgument: get(options, "storeArgument") ?? TABLE_CODEGEN_DEFAULTS.storeArgument,
-    // dataStruct is true if there are at least 2 value fields
-    dataStruct: get(options, "dataStruct") ?? Object.keys(input.schema).length - input.key.length > 1
-  };
-}
-function resolveTable(input, scope = AbiTypeScope) {
-  const namespaceLabel = input.namespaceLabel ?? TABLE_DEFAULTS.namespaceLabel;
-  const namespace = input.namespace ?? namespaceLabel;
-  const label = input.label;
-  const name = input.name ?? label.slice(0, 16);
-  const type = input.type ?? TABLE_DEFAULTS.type;
-  const tableId = (0, import_common4.resourceToHex)({ type, namespace, name });
-  return {
-    label,
-    type,
-    namespace,
-    namespaceLabel,
-    name,
-    tableId,
-    schema: resolveSchema(input.schema, scope),
-    key: input.key,
-    codegen: resolveTableCodegen(input),
-    deploy: mergeIfUndefined(input.deploy ?? {}, TABLE_DEPLOY_DEFAULTS)
-  };
-}
-function defineTable(input, scope = AbiTypeScope) {
-  validateTable(input, scope);
-  return resolveTable(input, scope);
-}
-
-// ts/config/v2/tableShorthand.ts
-var import_internal6 = require("@latticexyz/schema-type/internal");
-var NoStaticKeyFieldError = "Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.";
-function isTableShorthandInput(shorthand) {
-  return typeof shorthand === "string" || isObject(shorthand) && Object.values(shorthand).every((value) => typeof value === "string");
-}
-function validateTableShorthand(shorthand, scope = AbiTypeScope) {
-  if (typeof shorthand === "string") {
-    if ((0, import_internal6.isFixedArrayAbiType)(shorthand) || hasOwnKey(scope.types, shorthand)) {
-      return;
-    }
-    throw new Error(`Invalid ABI type. \`${shorthand}\` not found in scope.`);
-  }
-  if (typeof shorthand === "object" && shorthand !== null) {
-    if (isSchemaInput(shorthand, scope)) {
-      if (hasOwnKey(shorthand, "id") && (0, import_internal6.isStaticAbiType)(scope.types[shorthand.id])) {
-        return;
-      }
-      throw new Error(`Invalid schema. Expected an \`id\` field with a static ABI type or an explicit \`key\` option.`);
-    }
-    throw new Error(`Invalid schema. Are you using invalid types or missing types in your scope?`);
-  }
-  throw new Error(`Invalid table shorthand.`);
-}
-function expandTableShorthand(shorthand, scope) {
-  if (typeof shorthand === "string") {
-    return {
-      schema: {
-        id: "bytes32",
-        value: shorthand
-      },
-      key: ["id"]
-    };
-  }
-  if (isSchemaInput(shorthand, scope)) {
-    return {
-      schema: shorthand,
-      key: ["id"]
-    };
-  }
-  return shorthand;
-}
-function defineTableShorthand(input, scope = AbiTypeScope) {
-  validateTableShorthand(input, scope);
-  return expandTableShorthand(input, scope);
-}
-
-// ts/config/v2/tables.ts
-function validateTables(input, scope) {
-  if (isObject(input)) {
-    for (const table of Object.values(input)) {
-      if (isTableShorthandInput(table)) {
-        validateTableShorthand(table, scope);
-      } else {
-        validateTable(table, scope, { inStoreContext: true });
-      }
-    }
-    return;
-  }
-  throw new Error(`Expected tables config, received ${JSON.stringify(input)}`);
-}
-function resolveTables(tables, scope) {
-  return Object.fromEntries(
-    Object.entries(tables).map(([label, table]) => {
-      return [label, resolveTable(mergeIfUndefined(expandTableShorthand(table, scope), { label }), scope)];
-    })
-  );
-}
-function defineTables(input, scope = AbiTypeScope) {
-  validateTables(input, scope);
-  return resolveTables(input, scope);
-}
-
-// ts/config/v2/namespace.ts
-function validateNamespace(input, scope) {
-  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
-    throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
-  }
-  if (hasOwnKey(input, "tables")) {
-    validateTables(input.tables, scope);
-  }
-}
-function resolveNamespace(input, scope = AbiTypeScope) {
-  const namespaceLabel = input.label;
-  const namespace = input.namespace ?? namespaceLabel.slice(0, 14);
-  return {
-    label: namespaceLabel,
-    namespace,
-    tables: resolveTables(
-      (0, import_util2.flatMorph)(input.tables ?? {}, (label, table) => {
-        return [label, mergeIfUndefined(expandTableShorthand(table, scope), { namespace, namespaceLabel })];
-      }),
-      scope
-    )
-  };
-}
-
-// ts/config/v2/namespaces.ts
-var import_util3 = require("@ark/util");
-var import_utils2 = require("@latticexyz/common/utils");
-function validateNamespaces(namespaces, scope) {
-  if (!isObject(namespaces)) {
-    throw new Error(`Expected namespaces, received ${JSON.stringify(namespaces)}`);
-  }
-  for (const namespace of Object.values(namespaces)) {
-    validateNamespace(namespace, scope);
-  }
-}
-function resolveNamespaces(input, scope) {
-  if (!isObject(input)) {
-    throw new Error(`Expected namespaces config, received ${JSON.stringify(input)}`);
-  }
-  const namespaces = (0, import_util3.flatMorph)(input, (label, namespace) => [
-    label,
-    resolveNamespace(mergeIfUndefined(namespace, { label }), scope)
-  ]);
-  const duplicates = Array.from((0, import_utils2.groupBy)(Object.values(namespaces), (namespace) => namespace.namespace).entries()).filter(([, entries]) => entries.length > 1).map(([namespace]) => namespace);
-  if (duplicates.length > 0) {
-    throw new Error(`Found namespaces defined more than once in config: ${duplicates.join(", ")}`);
-  }
-  return namespaces;
-}
-function defineNamespaces(input, scope = AbiTypeScope) {
-  validateNamespaces(input, scope);
-  return resolveNamespaces(input, scope);
-}
-
-// ts/config/v2/userTypes.ts
-var import_utils3 = require("@latticexyz/common/utils");
-var import_internal7 = require("@latticexyz/schema-type/internal");
-function extractInternalType(userTypes) {
-  return (0, import_utils3.mapObject)(userTypes, (userType) => userType.type);
-}
-function isUserTypes(userTypes) {
-  return isObject(userTypes) && Object.values(userTypes).every((userType) => (0, import_internal7.isSchemaAbiType)(userType.type));
-}
-function scopeWithUserTypes(userTypes, scope = AbiTypeScope) {
-  return isUserTypes(userTypes) ? extendScope(scope, extractInternalType(userTypes)) : scope;
-}
-function validateUserTypes(userTypes) {
-  if (!isObject(userTypes)) {
-    throw new Error(`Expected userTypes, received ${JSON.stringify(userTypes)}`);
-  }
-  for (const { type } of Object.values(userTypes)) {
-    if (!hasOwnKey(AbiTypeScope.types, type)) {
-      throw new Error(`"${String(type)}" is not a valid ABI type.`);
-    }
-  }
-}
-
-// ts/config/v2/store.ts
-function extendedScope(input) {
-  return scopeWithEnums(get(input, "enums"), scopeWithUserTypes(get(input, "userTypes")));
-}
-function validateStore(input) {
-  const scope = extendedScope(input);
-  if (hasOwnKey(input, "namespaces")) {
-    if (hasOwnKey(input, "namespace") || hasOwnKey(input, "tables")) {
-      throw new Error("Cannot use `namespaces` with `namespace` or `tables` keys.");
-    }
-    validateNamespaces(input.namespaces, scope);
-  }
-  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
-    throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
-  }
-  if (hasOwnKey(input, "tables")) {
-    validateTables(input.tables, scope);
-  }
-  if (hasOwnKey(input, "userTypes")) {
-    validateUserTypes(input.userTypes);
-  }
-}
-function resolveStore(input) {
-  const scope = extendedScope(input);
-  const baseNamespace = input.namespace ?? CONFIG_DEFAULTS["namespace"];
-  const namespaces = input.namespaces ? {
-    multipleNamespaces: true,
-    namespace: null,
-    namespaces: resolveNamespaces(input.namespaces, scope)
-  } : {
-    multipleNamespaces: false,
-    namespace: baseNamespace,
-    namespaces: resolveNamespaces({ [baseNamespace]: input }, scope)
-  };
-  const tables = flattenNamespacedTables(namespaces);
-  return {
-    ...namespaces,
-    tables,
-    sourceDirectory: input.sourceDirectory ?? CONFIG_DEFAULTS["sourceDirectory"],
-    userTypes: input.userTypes ?? {},
-    enums: resolveEnums(input.enums ?? {}),
-    enumValues: mapEnums(input.enums ?? {}),
-    codegen: resolveCodegen(input.codegen)
-  };
-}
-function defineStore(input) {
-  validateStore(input);
-  return resolveStore(input);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AbiTypeScope,
-  CODEGEN_DEFAULTS,
-  CONFIG_DEFAULTS,
-  NoStaticKeyFieldError,
-  Scope,
-  TABLE_CODEGEN_DEFAULTS,
-  TABLE_DEFAULTS,
-  TABLE_DEPLOY_DEFAULTS,
-  defineNamespaces,
-  defineSchema,
-  defineStore,
-  defineTable,
-  defineTableShorthand,
-  defineTables,
-  emptyRecord,
-  expandTableShorthand,
-  extendScope,
-  extendedScope,
-  extractInternalType,
-  flattenNamespacedTables,
-  flattenStoreLogs,
-  get,
-  getPath,
-  getRecord,
-  getStaticDataLocation,
-  getStoreLogs,
-  hasOwnKey,
-  isObject,
-  isSchemaInput,
-  isTableShorthandInput,
-  isUserTypes,
-  isValidPrimaryKey,
-  logToRecord,
-  mapEnums,
-  mergeIfUndefined,
-  resolveCodegen,
-  resolveEnums,
-  resolveNamespace,
-  resolveNamespaces,
-  resolveSchema,
-  resolveStore,
-  resolveTable,
-  resolveTableCodegen,
-  resolveTables,
-  scopeWithEnums,
-  scopeWithUserTypes,
-  validateNamespace,
-  validateNamespaces,
-  validateSchema,
-  validateStore,
-  validateTable,
-  validateTableShorthand,
-  validateTables,
-  validateUserTypes
-});
-//# sourceMappingURL=internal.cjs.map