@xyo-network/sdk 7.0.3 → 7.0.4

package/dist/_pkg/module-model/neutral/index.mjs

@@ -1,702 +0,0 @@
-// src/Config/Archiving.ts
-import * as z from "zod/mini";
-var ArchivingModuleConfigZod = z.object({
-  archiving: z.optional(z.object({
-    archivists: z.optional(z.array(z.custom())),
-    queries: z.optional(z.array(z.custom()))
-  }))
-});
-
-// src/Config/Config.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk";
-import {
-  asSchema,
-  PayloadZod
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z4 from "zod/mini";
-
-// src/Config/Fields.ts
-import * as z2 from "zod/mini";
-var ModuleConfigFieldsZod = z2.object({
-  allowedQueries: z2.optional(z2.array(z2.custom())),
-  archivist: z2.optional(z2.custom()),
-  labels: z2.optional(z2.custom()),
-  logLevel: z2.optional(z2.custom()),
-  name: z2.optional(z2.custom()),
-  paging: z2.optional(z2.record(z2.string(), z2.object({ size: z2.optional(z2.number()) }))),
-  retry: z2.optional(z2.custom()),
-  security: z2.optional(z2.custom()),
-  sign: z2.optional(z2.boolean()),
-  storeQueries: z2.optional(z2.boolean()),
-  timeBudget: z2.optional(z2.number()),
-  timestamp: z2.optional(z2.boolean())
-});
-
-// src/Config/Reentrancy.ts
-import * as z3 from "zod/mini";
-var ArchivingReentrancyConfigZod = z3.object({
-  reentrancy: z3.optional(z3.object({
-    action: z3.union([z3.literal("skip"), z3.literal("wait")]),
-    scope: z3.literal("global")
-  }))
-});
-
-// src/Config/Config.ts
-var ModuleConfigSchema = asSchema("network.xyo.module.config", true);
-var ModuleConfigZod = z4.extend(PayloadZod, {
-  ...ModuleConfigFieldsZod.shape,
-  ...ArchivingModuleConfigZod.shape,
-  ...ArchivingReentrancyConfigZod.shape
-});
-var isModuleConfig = zodIsFactory(ModuleConfigZod);
-var asModuleConfig = zodAsFactory(ModuleConfigZod, "asModuleConfig");
-var toModuleConfig = zodToFactory(ModuleConfigZod, "toModuleConfig");
-
-// src/Config/Security.ts
-import * as z5 from "zod/mini";
-var ModuleSecurityConfigZod = z5.object({
-  allowAnonymous: z5.optional(z5.boolean()),
-  allowed: z5.optional(z5.record(z5.custom(), z5.array(z5.custom()))),
-  disallowed: z5.optional(z5.record(z5.custom(), z5.array(z5.custom())))
-});
-
-// src/CreatableModule/CreatableModule.ts
-function creatableModule() {
-  return (constructor) => {
-    constructor;
-  };
-}
-
-// src/CreatableModule/CreatableModuleRegistry.ts
-import { isTruthy } from "@xylabs/sdk";
-import { asSchema as asSchema2 } from "../../sdk-protocol/neutral/index.mjs";
-var buildModuleFactory = (mod, labels) => {
-  const factory5 = {
-    // Destructure instance properties
-    ...mod,
-    configSchemas: mod.configSchemas,
-    // Copy static methods
-    create: mod.create.bind(mod),
-    defaultConfigSchema: mod.defaultConfigSchema,
-    // Merge module & supplied labels
-    labels: { ...mod.labels, ...labels }
-  };
-  return factory5;
-};
-var registerCreatableModuleFactory = (registry, factory5, labels, primary = false) => {
-  const primarySchemas = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
-  for (const primarySchema of primarySchemas) {
-    if (!factory5.configSchemas.includes(primarySchema)) {
-      console.warn(`Primary schema ${String(primary)} not found in factory configSchemas`);
-    }
-  }
-  const isPrimaryForSchema = (schema) => {
-    switch (typeof primary) {
-      case "boolean": {
-        return primary;
-      }
-      case "string": {
-        return schema === primary;
-      }
-      case "object": {
-        if (Array.isArray(primary)) {
-          return primary.includes(schema);
-        }
-      }
-    }
-    throw new Error(`Invalid primary value: ${String(primary)}`);
-  };
-  const factoryClone = buildModuleFactory(factory5, labels);
-  registry[factory5.defaultConfigSchema] = [factoryClone, ...registry[factoryClone.defaultConfigSchema] ?? []];
-  for (const schema of factoryClone.configSchemas) {
-    registry[schema] = isPrimaryForSchema(schema) ? [factoryClone, ...registry[schema] ?? []] : [...registry[schema] ?? [], factoryClone];
-  }
-};
-var registerCreatableModuleFactories = (factories, registry = {}, primary = false) => {
-  for (const factory5 of factories) {
-    registerCreatableModuleFactory(registry, factory5, void 0, primary);
-  }
-  return registry;
-};
-var assignCreatableModuleRegistry = (target = {}, ...sources) => {
-  for (const source of sources)
-    for (const [schemaString, factories] of Object.entries(source)) {
-      const schema = asSchema2(schemaString, true);
-      if (factories) {
-        const existingFactories = target[schema];
-        target[schema] = [...existingFactories ?? [], ...factories];
-      }
-    }
-  return target;
-};
-
-// src/CreatableModule/LabeledCreatableModule.ts
-function labeledCreatableModule() {
-  return (constructor) => {
-    constructor;
-  };
-}
-
-// src/CreatableModule/LabeledCreatableModuleFactory.ts
-var hasLabels = (factory5) => {
-  return factory5.labels !== void 0;
-};
-function labeledCreatableModuleFactory() {
-  return (constructor) => {
-    constructor;
-  };
-}
-
-// src/CreatableModule/ModuleFactory.ts
-import { assertEx } from "@xylabs/sdk";
-var ModuleFactory = class _ModuleFactory {
-  configSchemas;
-  creatableModule;
-  defaultConfigSchema;
-  defaultLogger;
-  defaultParams;
-  labels;
-  constructor(creatableModule2, params, labels = {}) {
-    this.creatableModule = creatableModule2;
-    this.defaultParams = params;
-    this.configSchemas = creatableModule2.configSchemas;
-    this.defaultConfigSchema = creatableModule2.defaultConfigSchema;
-    assertEx(this.configSchemas.includes(this.defaultConfigSchema), () => "defaultConfigSchema must be in configSchemas");
-    this.labels = Object.assign({}, creatableModule2.labels ?? {}, labels ?? {});
-  }
-  static withParams(creatableModule2, params, labels = {}) {
-    return new _ModuleFactory(creatableModule2, params, labels);
-  }
-  create(params) {
-    const mergedParams = {
-      ...this.defaultParams,
-      ...params,
-      config: {
-        schema: this.creatableModule.defaultConfigSchema,
-        ...this.defaultParams?.config,
-        ...params?.config
-      }
-    };
-    return this.creatableModule.create(mergedParams);
-  }
-  factory(params, labels = {}) {
-    return new _ModuleFactory(this.creatableModule, params, labels);
-  }
-};
-
-// src/DetailsError.ts
-var ModuleDetailsError = class extends Error {
-  details;
-  constructor(message, details) {
-    super(message);
-    this.details = details;
-    this.name = "ModuleError";
-  }
-};
-
-// src/instance/asModuleInstance.ts
-import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk";
-
-// src/instance/isModuleInstance.ts
-import { IsObjectFactory as IsObjectFactory2 } from "@xylabs/sdk";
-
-// src/QueryableModule/asQueryableModule.ts
-import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk";
-
-// src/Queries/Manifest.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema3,
-  PayloadZodOfSchema,
-  QueryFieldsZod
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z6 from "zod/mini";
-var ModuleManifestQuerySchema = asSchema3("network.xyo.query.module.manifest", true);
-var ModuleManifestQueryZod = z6.extend(PayloadZodOfSchema(ModuleManifestQuerySchema), {
-  ...QueryFieldsZod.shape,
-  maxDepth: z6.optional(z6.number())
-});
-var isModuleManifestQuery = zodIsFactory2(ModuleManifestQueryZod);
-var asModuleManifestQuery = zodAsFactory2(ModuleManifestQueryZod, "asModuleManifestQuery");
-var toModuleManifestQuery = zodToFactory2(ModuleManifestQueryZod, "toModuleManifestQuery");
-
-// src/Queries/ModuleAddress/Query.ts
-import {
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema4,
-  PayloadZodOfSchema as PayloadZodOfSchema2,
-  QueryFieldsZod as QueryFieldsZod2
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z7 from "zod/mini";
-var ModuleAddressQuerySchema = asSchema4("network.xyo.query.module.address", true);
-var ModuleAddressQueryZod = z7.extend(PayloadZodOfSchema2(ModuleAddressQuerySchema), { ...QueryFieldsZod2.shape });
-var isModuleAddressQuery = zodIsFactory3(ModuleAddressQueryZod);
-var asModuleAddressQuery = zodAsFactory3(ModuleAddressQueryZod, "asModuleAddressQuery");
-var toModuleAddressQuery = zodToFactory3(ModuleAddressQueryZod, "toModuleAddressQuery");
-
-// src/Queries/State.ts
-import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory4
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema5,
-  PayloadZodOfSchema as PayloadZodOfSchema3,
-  QueryFieldsZod as QueryFieldsZod3
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z8 from "zod/mini";
-var ModuleStateQuerySchema = asSchema5("network.xyo.query.module.state", true);
-var ModuleStateQueryZod = z8.extend(PayloadZodOfSchema3(ModuleStateQuerySchema), { ...QueryFieldsZod3.shape });
-var isModuleStateQuery = zodIsFactory4(ModuleStateQueryZod);
-var asModuleStateQuery = zodAsFactory4(ModuleStateQueryZod, "asModuleStateQuery");
-var toModuleStateQuery = zodToFactory4(ModuleStateQueryZod, "toModuleStateQuery");
-
-// src/Queries/Subscribe.ts
-import {
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory5
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema6,
-  PayloadZodOfSchema as PayloadZodOfSchema4,
-  QueryFieldsZod as QueryFieldsZod4
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z9 from "zod/mini";
-var ModuleSubscribeQuerySchema = asSchema6("network.xyo.query.module.subscribe", true);
-var ModuleSubscribeQueryZod = z9.extend(PayloadZodOfSchema4(ModuleSubscribeQuerySchema), {
-  ...QueryFieldsZod4.shape,
-  /** @field The address that will receive notifications */
-  address: z9.custom(),
-  /** @field A subscribe with a null for filter is an unsubscribe */
-  filter: z9.optional(z9.nullable(z9.custom())),
-  /** @field The maximum events queued per send [may increase frequency] */
-  maxQueue: z9.optional(z9.number())
-});
-var isModuleSubscribeQuery = zodIsFactory5(ModuleSubscribeQueryZod);
-var asModuleSubscribeQuery = zodAsFactory5(ModuleSubscribeQueryZod, "asModuleSubscribeQuery");
-var toModuleSubscribeQuery = zodToFactory5(ModuleSubscribeQueryZod, "toModuleSubscribeQuery");
-
-// src/QueryableModule/asQueryableModuleObject.ts
-import { AsObjectFactory } from "@xylabs/sdk";
-
-// src/QueryableModule/isQueryableModuleObject.ts
-import { IsObjectFactory } from "@xylabs/sdk";
-var requiredQueryableModuleShape = {
-  address: "string",
-  queries: "array",
-  query: "function"
-};
-var requiredModuleShape = requiredQueryableModuleShape;
-var factory = new IsObjectFactory();
-var isQueryableModuleObject = factory.create(requiredQueryableModuleShape);
-var isModuleObject = isQueryableModuleObject;
-
-// src/QueryableModule/asQueryableModuleObject.ts
-var asQueryableModuleObject = AsObjectFactory.create(isQueryableModuleObject);
-var asModuleObject = asQueryableModuleObject;
-
-// src/QueryableModule/IsQueryableModuleFactory.ts
-var IsQueryableModuleFactory = class {
-  create(expectedQueries, additionalChecks) {
-    const result = (obj, config) => {
-      const mod = asQueryableModuleObject(obj);
-      return isQueryableModuleObject(mod, config) && (expectedQueries?.reduce((prev, query) => prev && mod.queries.includes(query), true) ?? true) && (additionalChecks?.reduce((prev, check) => prev && check(obj, config), true) ?? true);
-    };
-    return result;
-  }
-};
-var IsModuleFactory = class extends IsQueryableModuleFactory {
-};
-
-// src/QueryableModule/isQueryableModule.ts
-var requiredQueryableModuleQueries = [ModuleStateQuerySchema];
-var requiredModuleQueries = requiredQueryableModuleQueries;
-var factory2 = new IsQueryableModuleFactory();
-var isQueryableModule = factory2.create(requiredQueryableModuleQueries, [isQueryableModuleObject]);
-var isModule = isQueryableModule;
-
-// src/QueryableModule/asQueryableModule.ts
-var asQueryableModule = AsObjectFactory2.create(isQueryableModule);
-var asModule = asQueryableModule;
-
-// src/instance/isModuleInstance.ts
-var requiredModuleInstanceFunctions = {
-  manifest: "function",
-  state: "function"
-};
-var factory3 = new IsObjectFactory2();
-var isModuleInstance = factory3.create(requiredModuleInstanceFunctions, [isQueryableModule]);
-
-// src/instance/asModuleInstance.ts
-var asModuleInstance = AsObjectFactory3.create(isModuleInstance);
-
-// src/instance/attachable/asAttachableInstance.ts
-import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk";
-
-// src/instance/attachable/isAttachableInstance.ts
-import { IsObjectFactory as IsObjectFactory3 } from "@xylabs/sdk";
-var requiredAttachableModuleInstanceFunctions = {
-  downResolver: "object",
-  upResolver: "object"
-};
-var factory4 = new IsObjectFactory3();
-var isAttachableModuleInstance = factory4.create(requiredAttachableModuleInstanceFunctions, [
-  isModuleInstance
-]);
-
-// src/instance/attachable/asAttachableInstance.ts
-var asAttachableModuleInstance = AsObjectFactory4.create(isAttachableModuleInstance);
-
-// src/instance/attachable/AttachableInstance.ts
-import { IsObjectFactory as IsObjectFactory4 } from "@xylabs/sdk";
-var IsAttachableModuleInstanceFactory = class extends IsObjectFactory4 {
-};
-
-// src/instance/Instance.ts
-import { IsObjectFactory as IsObjectFactory5, toSafeJsonString } from "@xylabs/sdk";
-var DeadModuleError = class _DeadModuleError extends Error {
-  error;
-  id;
-  constructor(id, error, msg = "Dead Module Error") {
-    super(`${msg} [${id}]: ${error?.message ?? toSafeJsonString(error)}`);
-    this.id = id;
-    this.error = error;
-    Object.setPrototypeOf(this, _DeadModuleError.prototype);
-  }
-};
-var IsInstanceFactory = class extends IsObjectFactory5 {
-};
-
-// src/instance/ObjectFilter.ts
-var isAddressObjectFilter = (value) => value.address !== void 0;
-var isNameObjectFilter = (value) => value.name !== void 0;
-var isQueryObjectFilter = (value) => value.query !== void 0;
-
-// src/instance/ModuleFilter.ts
-var isAddressModuleFilter = isAddressObjectFilter;
-var isNameModuleFilter = isNameObjectFilter;
-var isQueryModuleFilter = isQueryObjectFilter;
-
-// src/instance/ObjectResolver.ts
-var isObjectResolver = (value) => {
-  return typeof value.resolve === "function";
-};
-var ObjectResolverPriority = {
-  Disabled: -1,
-  VeryLow: 0,
-  Low: 1,
-  Normal: 2,
-  High: 3,
-  VeryHigh: 4
-};
-
-// src/instance/ModuleResolver.ts
-var isModuleResolver = isObjectResolver;
-
-// src/Labels/Labels.ts
-var hasAllLabels = (source, required) => {
-  if (!required) return true;
-  return Object.entries(required).every(([key, value]) => {
-    return Object.hasOwn(source ?? {}, key) && source?.[key] === value;
-  });
-};
-
-// src/Labels/standard/View.ts
-var ModuleLimitationLabelName = "network.xyo.module.limitation";
-var ModuleLimitationViewLabel = { ModuleLimitationLabelName: "view" };
-
-// src/lib/duplicateModules.ts
-var duplicateModules = (value, index, array4) => {
-  return array4.findIndex((v) => v.address === value.address) === index;
-};
-
-// src/lib/serializable.ts
-var isSerializable = (value, maxDepth = 10) => {
-  if (maxDepth <= 0) {
-    return false;
-  }
-  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-    return true;
-  }
-  if (Array.isArray(value)) {
-    return value.every((item) => isSerializable(item, maxDepth - 1));
-  }
-  if (typeof value === "object") {
-    if (value instanceof Date || value instanceof RegExp) {
-      return true;
-    }
-    if (value instanceof Set || value instanceof Map) {
-      return false;
-    }
-    if (value !== null && value !== void 0) {
-      return Object.values(value).every((item) => isSerializable(item, maxDepth - 1));
-    }
-  }
-  return false;
-};
-
-// src/ModuleIdentifier.ts
-import { isAddress } from "@xylabs/sdk";
-var MODULE_PATH_SEPARATOR = ":";
-var DisallowedModuleIdentifierCharacters = {
-  " ": true,
-  "!": true,
-  '"': true,
-  "#": true,
-  "$": true,
-  "%": true,
-  "&": true,
-  "'": true,
-  "(": true,
-  ")": true,
-  "*": true,
-  ",": true,
-  ".": true,
-  "/": true,
-  ":": true,
-  ";": true,
-  "<": true,
-  "=": true,
-  ">": true,
-  "?": true,
-  "@": true,
-  "[": true,
-  "]": true,
-  "^": true,
-  "_": true,
-  "{": true,
-  "|": true,
-  "}": true,
-  "~": true
-};
-var ReservedModuleIdentifierCharacters = new Set(
-  Object.keys(DisallowedModuleIdentifierCharacters)
-);
-var isModuleName = (value) => {
-  return typeof value === "string" && !isAddress(value) && !includesReservedModuleIdentifierCharacter(value);
-};
-var includesReservedModuleIdentifierCharacter = (value) => {
-  return typeof value === "string" && [...value].some((char) => ReservedModuleIdentifierCharacters.has(char));
-};
-var isModuleIdentifierPart = (value) => {
-  return isModuleName(value) || isAddress(value);
-};
-
-// src/Payload/Address.ts
-import {
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory6,
-  zodToFactory as zodToFactory6
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema7,
-  PayloadZodOfSchema as PayloadZodOfSchema5
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z10 from "zod/mini";
-var AddressSchema = asSchema7("network.xyo.address", true);
-var AddressChildSchema = asSchema7("network.xyo.address.child", true);
-var AddressPayloadZod = z10.extend(PayloadZodOfSchema5(AddressSchema), { address: z10.custom() });
-var isAddressPayload = zodIsFactory6(AddressPayloadZod);
-var asAddressPayload = zodAsFactory6(AddressPayloadZod, "asAddressPayload");
-var toAddressPayload = zodToFactory6(AddressPayloadZod, "toAddressPayload");
-var asOptionalAddressPayload = asAddressPayload;
-var AddressChildPayloadZod = z10.extend(PayloadZodOfSchema5(AddressChildSchema), {
-  address: z10.custom(),
-  path: z10.optional(z10.string()),
-  root: z10.optional(z10.custom())
-});
-var isAddressChildPayload = zodIsFactory6(AddressChildPayloadZod);
-var asAddressChildPayload = zodAsFactory6(AddressChildPayloadZod, "asAddressChildPayload");
-var toAddressChildPayload = zodToFactory6(AddressChildPayloadZod, "toAddressChildPayload");
-
-// src/Payload/AddressPreviousHash.ts
-import {
-  zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory7,
-  zodToFactory as zodToFactory7
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema8,
-  PayloadZodOfSchema as PayloadZodOfSchema6
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z11 from "zod/mini";
-var AddressPreviousHashSchema = asSchema8("network.xyo.address.hash.previous", true);
-var AddressPreviousHashPayloadZod = z11.extend(PayloadZodOfSchema6(AddressPreviousHashSchema), {
-  address: z11.custom(),
-  previousHash: z11.optional(z11.string())
-});
-var isAddressPreviousHashPayload = zodIsFactory7(AddressPreviousHashPayloadZod);
-var asAddressPreviousHashPayload = zodAsFactory7(AddressPreviousHashPayloadZod, "asAddressPreviousHashPayload");
-var toAddressPreviousHashPayload = zodToFactory7(AddressPreviousHashPayloadZod, "toAddressPreviousHashPayload");
-
-// src/Payload/Description.ts
-import {
-  zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory8,
-  zodToFactory as zodToFactory8
-} from "@xylabs/sdk";
-import { asSchema as asSchema9, PayloadZodOfSchema as PayloadZodOfSchema7 } from "../../sdk-protocol/neutral/index.mjs";
-import * as z12 from "zod/mini";
-var ModuleDescriptionSchema = asSchema9("network.xyo.module.description", true);
-var ModuleDescriptionPayloadZod = z12.intersection(PayloadZodOfSchema7(ModuleDescriptionSchema), z12.custom());
-var isModuleDescriptionPayload = zodIsFactory8(ModuleDescriptionPayloadZod);
-var asModuleDescriptionPayload = zodAsFactory8(ModuleDescriptionPayloadZod, "asModuleDescriptionPayload");
-var toModuleDescriptionPayload = zodToFactory8(ModuleDescriptionPayloadZod, "toModuleDescriptionPayload");
-
-// src/Payload/ModuleState.ts
-import {
-  zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory9,
-  zodToFactory as zodToFactory9
-} from "@xylabs/sdk";
-import {
-  asSchema as asSchema10,
-  isPayloadOfSchemaTypeWithSources,
-  PayloadZodOfSchema as PayloadZodOfSchema8
-} from "../../sdk-protocol/neutral/index.mjs";
-import * as z13 from "zod/mini";
-var ModuleStateSchema = asSchema10("network.xyo.module.state", true);
-var ModuleStateZod = z13.extend(PayloadZodOfSchema8(ModuleStateSchema), { state: z13.custom() });
-var isModuleStateInternal = zodIsFactory9(ModuleStateZod);
-var isModuleState = (payload) => isModuleStateInternal(payload);
-var isModuleStateWithSources = (payload) => {
-  return isPayloadOfSchemaTypeWithSources(ModuleStateSchema)(payload);
-};
-var asModuleState = zodAsFactory9(ModuleStateZod, "asModuleState");
-var toModuleState = zodToFactory9(ModuleStateZod, "toModuleState");
-var asOptionalModuleState = asModuleState;
-
-// src/withModule.ts
-var WithFactory = {
-  create: (typeCheck) => {
-    return (mod, closure) => {
-      return typeCheck(mod) ? closure(mod) : void 0;
-    };
-  }
-};
-export {
-  AddressChildPayloadZod,
-  AddressChildSchema,
-  AddressPayloadZod,
-  AddressPreviousHashPayloadZod,
-  AddressPreviousHashSchema,
-  AddressSchema,
-  ArchivingModuleConfigZod,
-  ArchivingReentrancyConfigZod,
-  DeadModuleError,
-  DisallowedModuleIdentifierCharacters,
-  IsAttachableModuleInstanceFactory,
-  IsInstanceFactory,
-  IsModuleFactory,
-  IsQueryableModuleFactory,
-  MODULE_PATH_SEPARATOR,
-  ModuleAddressQuerySchema,
-  ModuleAddressQueryZod,
-  ModuleConfigFieldsZod,
-  ModuleConfigSchema,
-  ModuleConfigZod,
-  ModuleDescriptionPayloadZod,
-  ModuleDescriptionSchema,
-  ModuleDetailsError,
-  ModuleFactory,
-  ModuleLimitationLabelName,
-  ModuleLimitationViewLabel,
-  ModuleManifestQuerySchema,
-  ModuleManifestQueryZod,
-  ModuleSecurityConfigZod,
-  ModuleStateQuerySchema,
-  ModuleStateQueryZod,
-  ModuleStateSchema,
-  ModuleStateZod,
-  ModuleSubscribeQuerySchema,
-  ModuleSubscribeQueryZod,
-  ObjectResolverPriority,
-  ReservedModuleIdentifierCharacters,
-  WithFactory,
-  asAddressChildPayload,
-  asAddressPayload,
-  asAddressPreviousHashPayload,
-  asAttachableModuleInstance,
-  asModule,
-  asModuleAddressQuery,
-  asModuleConfig,
-  asModuleDescriptionPayload,
-  asModuleInstance,
-  asModuleManifestQuery,
-  asModuleObject,
-  asModuleState,
-  asModuleStateQuery,
-  asModuleSubscribeQuery,
-  asOptionalAddressPayload,
-  asOptionalModuleState,
-  asQueryableModule,
-  asQueryableModuleObject,
-  assignCreatableModuleRegistry,
-  creatableModule,
-  duplicateModules,
-  hasAllLabels,
-  hasLabels,
-  includesReservedModuleIdentifierCharacter,
-  isAddressChildPayload,
-  isAddressModuleFilter,
-  isAddressObjectFilter,
-  isAddressPayload,
-  isAddressPreviousHashPayload,
-  isAttachableModuleInstance,
-  isModule,
-  isModuleAddressQuery,
-  isModuleConfig,
-  isModuleDescriptionPayload,
-  isModuleIdentifierPart,
-  isModuleInstance,
-  isModuleManifestQuery,
-  isModuleName,
-  isModuleObject,
-  isModuleResolver,
-  isModuleState,
-  isModuleStateQuery,
-  isModuleStateWithSources,
-  isModuleSubscribeQuery,
-  isNameModuleFilter,
-  isNameObjectFilter,
-  isObjectResolver,
-  isQueryModuleFilter,
-  isQueryObjectFilter,
-  isQueryableModule,
-  isQueryableModuleObject,
-  isSerializable,
-  labeledCreatableModule,
-  labeledCreatableModuleFactory,
-  registerCreatableModuleFactories,
-  registerCreatableModuleFactory,
-  requiredAttachableModuleInstanceFunctions,
-  requiredModuleInstanceFunctions,
-  requiredModuleQueries,
-  requiredModuleShape,
-  requiredQueryableModuleQueries,
-  requiredQueryableModuleShape,
-  toAddressChildPayload,
-  toAddressPayload,
-  toAddressPreviousHashPayload,
-  toModuleAddressQuery,
-  toModuleConfig,
-  toModuleDescriptionPayload,
-  toModuleManifestQuery,
-  toModuleState,
-  toModuleStateQuery,
-  toModuleSubscribeQuery
-};