@xyo-network/sdk 2.102.3 → 7.0.2

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

@@ -0,0 +1,702 @@
+// 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
+};