@gqloom/core 0.10.1 → 0.11.0

package/dist/index.js

@@ -1,1915 +1,1753 @@
-import {
-  DERIVED_DEPENDENCIES,
-  FIELD_HIDDEN,
-  GET_GRAPHQL_TYPE,
-  IS_RESOLVER,
-  WEAVER_CONFIG,
-  assignContextMap,
-  getMemoizationMap,
-  getResolvingFields,
-  isOnlyMemoryPayload,
-  onlyMemoization,
-  parseResolvingFields,
-  symbols_exports
-} from "./chunk-JWAIAFGL.js";
+import { DERIVED_DEPENDENCIES, FIELD_HIDDEN, GET_GRAPHQL_TYPE, IS_RESOLVER, WEAVER_CONFIG, assignContextMap, getDeepResolvingFields, getMemoizationMap, getResolvingFields, isOnlyMemoryPayload, onlyMemoization, parseResolvingFields, symbols_exports } from "./context-CpbCknos.js";
+import { GraphQLError, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, assertName, isEnumType, isInputObjectType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, isUnionType, resolveObjMapThunk } from "graphql";
 
-// src/utils/args.ts
+//#region src/utils/args.ts
 function getOperationOptions(resolveOrOptions) {
-  if (typeof resolveOrOptions === "function") {
-    return { resolve: resolveOrOptions };
-  }
-  return resolveOrOptions;
+	if (typeof resolveOrOptions === "function") return { resolve: resolveOrOptions };
+	return resolveOrOptions;
 }
 function getSubscriptionOptions(subscribeOrOptions) {
-  if (typeof subscribeOrOptions === "function") {
-    return { subscribe: subscribeOrOptions };
-  }
-  return subscribeOrOptions;
+	if (typeof subscribeOrOptions === "function") return { subscribe: subscribeOrOptions };
+	return subscribeOrOptions;
 }
 function getFieldOptions({ description, deprecationReason, extensions }, extraExtensions) {
-  return {
-    description,
-    deprecationReason,
-    extensions: extraExtensions ? { ...extensions, ...extraExtensions } : extensions
-  };
+	return {
+		description,
+		deprecationReason,
+		extensions: extraExtensions ? {
+			...extensions,
+			...extraExtensions
+		} : extensions
+	};
 }
 
-// src/utils/middleware.ts
-var defaultOperations = [
-  "field",
-  "mutation",
-  "query",
-  "subscription.subscribe"
+//#endregion
+//#region src/utils/middleware.ts
+const defaultOperations = [
+	"field",
+	"mutation",
+	"query",
+	"subscription.subscribe"
 ];
 function applyMiddlewares(options, resolveFunction, middlewares) {
-  const next = (index) => {
-    if (index >= middlewares.length) {
-      return resolveFunction();
-    }
-    const middleware = middlewares[index];
-    const callableOptions = Object.assign(() => next(index + 1), {
-      ...options,
-      next: () => next(index + 1)
-    });
-    return middleware(callableOptions);
-  };
-  return next(0);
+	const next = (index) => {
+		if (index >= middlewares.length) return resolveFunction();
+		const middleware = middlewares[index];
+		const callableOptions = Object.assign(() => next(index + 1), {
+			...options,
+			next: () => next(index + 1)
+		});
+		return middleware(callableOptions);
+	};
+	return next(0);
 }
 function filterMiddlewares(operation, ...middlewareList) {
-  return middlewareList.reduce((acc, m) => {
-    if (!m) return acc;
-    acc.push(
-      ...ensureArray(m).filter((m2) => {
-        const ops = m2.operations ?? defaultOperations;
-        return ops.includes(operation);
-      })
-    );
-    return acc;
-  }, []);
+	return middlewareList.reduce((acc, m) => {
+		if (!m) return acc;
+		acc.push(...ensureArray(m).filter((m$1) => {
+			const ops = m$1.operations ?? defaultOperations;
+			return ops.includes(operation);
+		}));
+		return acc;
+	}, []);
 }
 function ensureArray(value) {
-  if (value != null && typeof value === "object" && Symbol.iterator in value) {
-    return Array.from(value);
-  }
-  return [value];
+	if (value != null && typeof value === "object" && Symbol.iterator in value) return Array.from(value);
+	return [value];
 }
 
-// src/utils/object.ts
+//#endregion
+//#region src/utils/object.ts
+/**
+* Creates an object map with the same keys as `map` and values generated by
+* running each value of `record` thru `fn`.
+*/
 function mapValue(record, fn) {
-  const result = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(record)) {
-    const value = fn(record[key], key);
-    if (value === SKIP) continue;
-    result[key] = value;
-  }
-  return result;
+	const result = Object.create(null);
+	for (const key of Object.keys(record)) {
+		const value = fn(record[key], key);
+		if (value === SKIP) continue;
+		result[key] = value;
+	}
+	return result;
 }
-var SKIP = Symbol.for("mapValue.skip");
+const SKIP = Symbol.for("mapValue.skip");
 mapValue.SKIP = SKIP;
 function toObjMap(obj) {
-  if (obj == null) {
-    return /* @__PURE__ */ Object.create(null);
-  }
-  if (Object.getPrototypeOf(obj) === null) {
-    return obj;
-  }
-  const map = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(obj)) {
-    map[key] = value;
-  }
-  return map;
+	if (obj == null) return Object.create(null);
+	if (Object.getPrototypeOf(obj) === null) return obj;
+	const map = Object.create(null);
+	for (const [key, value] of Object.entries(obj)) map[key] = value;
+	return map;
 }
 function notNullish(x) {
-  return x != null;
+	return x != null;
 }
 function deepMerge(...objects) {
-  const result = {};
-  for (const obj of objects) {
-    if (obj == null) continue;
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== null && typeof value === "object") {
-        if (Array.isArray(value)) {
-          if (!Array.isArray(result[key])) {
-            result[key] = [];
-          }
-          result[key] = [...result[key], ...value];
-        } else {
-          result[key] = deepMerge(result[key], value);
-        }
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
+	const result = {};
+	for (const obj of objects) {
+		if (obj == null) continue;
+		for (const [key, value] of Object.entries(obj)) if (value !== null && typeof value === "object") if (Array.isArray(value)) {
+			if (!Array.isArray(result[key])) result[key] = [];
+			result[key] = [...result[key], ...value];
+		} else result[key] = deepMerge(result[key], value);
+		else result[key] = value;
+	}
+	return result;
 }
+/**
+* Wraps the provided data in an object with a single key `"~meta"`.
+*
+* @template T - The type of the data to be wrapped.
+* @param {T} data - The data to be wrapped.
+* @returns {{ "~meta": T }} - An object with a single key `"~meta"` containing the provided data.
+* @example
+* const originalData = { key: "value" };
+* const metaData = meta(originalData);
+* console.log(metaData); // Output: { "~meta": { key: "value" } }
+*/
 function meta(data) {
-  return { "~meta": data };
+	return { "~meta": data };
 }
 
-// src/utils/string.ts
+//#endregion
+//#region src/utils/string.ts
 function pascalCase(str) {
-  return str.split(/[\s-_]+/).map(
-    (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
-  ).join("");
+	return str.split(/[\s-_]+/).map((word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
 function capitalize(str) {
-  return str.slice(0, 1).toUpperCase() + str.slice(1);
+	return str.slice(0, 1).toUpperCase() + str.slice(1);
 }
 function screamingSnakeCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[\s-_]+/).map((word) => word.toUpperCase()).join("_");
+	return str.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[\s-_]+/).map((word) => word.toUpperCase()).join("_");
 }
 
-// src/utils/error.ts
+//#endregion
+//#region src/utils/error.ts
 function markErrorLocation(error, ...locations) {
-  if (error instanceof Error) {
-    error.message = markLocation(error.message, ...locations);
-  }
-  return error;
+	if (error instanceof Error) error.message = markLocation(error.message, ...locations);
+	return error;
 }
 function tryIn(func, ...locations) {
-  try {
-    return func();
-  } catch (error) {
-    throw markErrorLocation(error, ...locations);
-  }
+	try {
+		return func();
+	} catch (error) {
+		throw markErrorLocation(error, ...locations);
+	}
 }
+/**
+* mark message with location
+* @param message origin message
+* @param locations where error happened
+* @returns message with location
+* @example markLocation("error", "banana") // "[banana] hello"
+* @example markLocation("error", fruit, banana) // "[fruit.banana] error"
+* @example markLocation("[banana] error", "fruit") // "[fruit.banana] error"
+* @example markLocation("[fruit.banana] error", "favorite") // "[favorite.fruit.banana] error"
+*/
 function markLocation(message, ...locations) {
-  if (locations.length === 0) {
-    return message;
-  }
-  const [existingPrefix, newMessage] = (() => {
-    const existingPrefixPattern = /^\[(.*?)\]/;
-    const match = existingPrefixPattern.exec(message);
-    if (match) return [match[1], message.slice(match[0].length).trim()];
-    return [void 0, message];
-  })();
-  const combinedLocation = locations.concat(existingPrefix ? [existingPrefix] : []).join(".");
-  return `[${combinedLocation}] ${newMessage}`;
+	if (locations.length === 0) return message;
+	const [existingPrefix, newMessage] = (() => {
+		const existingPrefixPattern = /^\[(.*?)\]/;
+		const match = existingPrefixPattern.exec(message);
+		if (match) return [match[1], message.slice(match[0].length).trim()];
+		return [void 0, message];
+	})();
+	const combinedLocation = locations.concat(existingPrefix ? [existingPrefix] : []).join(".");
+	return `[${combinedLocation}] ${newMessage}`;
 }
 
-// src/utils/loader.ts
-var LoomDataLoader = class _LoomDataLoader {
-  results;
-  resolvers;
-  constructor() {
-    this.results = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Load data for a given key.
-   * @param key - The key to load data for.
-   * @returns A promise that resolves to the loaded data.
-   */
-  load(key) {
-    const existing = this.results.get(key);
-    if (existing) return existing;
-    const promise = new Promise((resolve, reject) => {
-      this.resolvers.set(key, [resolve, reject]);
-      this.nextTickBatchLoad();
-    });
-    this.results.set(key, promise);
-    return promise;
-  }
-  /**
-   * Clear the cache and reset the loader.
-   */
-  clear() {
-    this.results = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-  }
-  async executeBatchLoad() {
-    if (this.resolvers.size === 0) return;
-    const resolvers = this.resolvers;
-    this.resolvers = /* @__PURE__ */ new Map();
-    const keys = Array.from(resolvers.keys());
-    try {
-      const list = await this.batchLoad(keys);
-      for (let i = 0; i < list.length; i++) {
-        const data = list[i];
-        const [resolve, reject] = resolvers.get(keys[i]) ?? [];
-        if (data instanceof Error) {
-          reject?.(data);
-        } else {
-          resolve?.(data);
-        }
-      }
-    } catch (error) {
-      for (const key of keys) {
-        const reject = resolvers.get(key)?.[1];
-        reject?.(error);
-      }
-    }
-  }
-  nextTickPromise;
-  nextTickBatchLoad() {
-    const load = async () => {
-      try {
-        while (this.resolvers.size > 0) {
-          await _LoomDataLoader.nextTick();
-          await this.executeBatchLoad();
-        }
-      } finally {
-        this.nextTickPromise = void 0;
-      }
-    };
-    this.nextTickPromise ??= load();
-    return this.nextTickPromise;
-  }
-  static nextTick() {
-    return new Promise((resolve) => setTimeout(resolve));
-  }
+//#endregion
+//#region src/utils/loader.ts
+/**
+* GraphQL Loom built-in data loader.
+*/
+var LoomDataLoader = class LoomDataLoader {
+	results;
+	resolvers;
+	constructor() {
+		this.results = /* @__PURE__ */ new Map();
+		this.resolvers = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Load data for a given key.
+	* @param key - The key to load data for.
+	* @returns A promise that resolves to the loaded data.
+	*/
+	load(key) {
+		const existing = this.results.get(key);
+		if (existing) return existing;
+		const promise = new Promise((resolve, reject) => {
+			this.resolvers.set(key, [resolve, reject]);
+			this.nextTickBatchLoad();
+		});
+		this.results.set(key, promise);
+		return promise;
+	}
+	/**
+	* Clear the cache and reset the loader.
+	*/
+	clear() {
+		this.results = /* @__PURE__ */ new Map();
+		this.resolvers = /* @__PURE__ */ new Map();
+	}
+	async executeBatchLoad() {
+		if (this.resolvers.size === 0) return;
+		const resolvers = this.resolvers;
+		this.resolvers = /* @__PURE__ */ new Map();
+		const keys = Array.from(resolvers.keys());
+		try {
+			const list = await this.batchLoad(keys);
+			for (let i = 0; i < list.length; i++) {
+				const data = list[i];
+				const [resolve, reject] = resolvers.get(keys[i]) ?? [];
+				if (data instanceof Error) reject?.(data);
+				else resolve?.(data);
+			}
+		} catch (error) {
+			for (const key of keys) {
+				const reject = resolvers.get(key)?.[1];
+				reject?.(error);
+			}
+		}
+	}
+	nextTickPromise;
+	nextTickBatchLoad() {
+		const load = async () => {
+			try {
+				while (this.resolvers.size > 0) {
+					await LoomDataLoader.nextTick();
+					await this.executeBatchLoad();
+				}
+			} finally {
+				this.nextTickPromise = void 0;
+			}
+		};
+		this.nextTickPromise ??= load();
+		return this.nextTickPromise;
+	}
+	static nextTick() {
+		return new Promise((resolve) => setTimeout(resolve));
+	}
 };
 var EasyDataLoader = class extends LoomDataLoader {
-  constructor(batchLoadFn) {
-    super();
-    this.batchLoadFn = batchLoadFn;
-  }
-  batchLoad(keys) {
-    return this.batchLoadFn(keys);
-  }
+	batchLoad(keys) {
+		return this.batchLoadFn(keys);
+	}
+	constructor(batchLoadFn) {
+		super();
+		this.batchLoadFn = batchLoadFn;
+	}
 };
 
-// src/resolver/silk.ts
-import {
-  GraphQLList,
-  GraphQLNonNull
-} from "graphql";
-
-// src/schema/weaver-context.ts
-import {
-  isEnumType,
-  isObjectType,
-  isScalarType,
-  isUnionType
-} from "graphql";
-var ref;
-var names = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/schema/weaver-context.ts
+let ref;
+const names = /* @__PURE__ */ new WeakMap();
 function initWeaverContext() {
-  return {
-    id: initWeaverContext.increasingID++,
-    loomObjectMap: /* @__PURE__ */ new Map(),
-    loomUnionMap: /* @__PURE__ */ new Map(),
-    inputMap: /* @__PURE__ */ new Map(),
-    interfaceMap: /* @__PURE__ */ new Map(),
-    configs: /* @__PURE__ */ new Map(),
-    getConfig(key) {
-      return this.configs.get(key);
-    },
-    setConfig(config) {
-      const key = config[WEAVER_CONFIG];
-      this.configs.set(key, config);
-    },
-    deleteConfig(key) {
-      this.configs.delete(key);
-    },
-    names,
-    namedTypes: /* @__PURE__ */ new Map(),
-    memoNamedType(gqlTypeValue) {
-      const gqlType = gqlTypeValue;
-      if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType) || isScalarType(gqlType)) {
-        this.namedTypes.set(gqlType.name, gqlType);
-      }
-      return gqlTypeValue;
-    },
-    getNamedType(name) {
-      return this.namedTypes.get(name);
-    },
-    vendorWeavers: /* @__PURE__ */ new Map()
-  };
+	return {
+		id: initWeaverContext.increasingID++,
+		loomObjectMap: /* @__PURE__ */ new Map(),
+		loomUnionMap: /* @__PURE__ */ new Map(),
+		inputMap: /* @__PURE__ */ new Map(),
+		interfaceMap: /* @__PURE__ */ new Map(),
+		configs: /* @__PURE__ */ new Map(),
+		getConfig(key) {
+			return this.configs.get(key);
+		},
+		setConfig(config) {
+			const key = config[WEAVER_CONFIG];
+			this.configs.set(key, config);
+		},
+		deleteConfig(key) {
+			this.configs.delete(key);
+		},
+		names,
+		namedTypes: /* @__PURE__ */ new Map(),
+		memoNamedType(gqlTypeValue) {
+			const gqlType = gqlTypeValue;
+			if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType) || isScalarType(gqlType)) this.namedTypes.set(gqlType.name, gqlType);
+			return gqlTypeValue;
+		},
+		getNamedType(name) {
+			return this.namedTypes.get(name);
+		},
+		vendorWeavers: /* @__PURE__ */ new Map()
+	};
 }
 initWeaverContext.increasingID = 1;
-var weaverContext = {
-  get id() {
-    return ref?.id;
-  },
-  get loomObjectMap() {
-    return ref?.loomObjectMap;
-  },
-  get loomUnionMap() {
-    return ref?.loomUnionMap;
-  },
-  get inputMap() {
-    return ref?.inputMap;
-  },
-  get interfaceMap() {
-    return ref?.interfaceMap;
-  },
-  get configs() {
-    return ref?.configs;
-  },
-  get vendorWeavers() {
-    return ref?.vendorWeavers;
-  },
-  getConfig(key) {
-    return ref?.getConfig(key);
-  },
-  setConfig(config) {
-    ref?.setConfig(config);
-  },
-  deleteConfig(key) {
-    ref?.deleteConfig(key);
-  },
-  get value() {
-    return ref;
-  },
-  useConfig(config, callback) {
-    const context = weaverContext.value ?? initWeaverContext();
-    context.setConfig(config);
-    const result = provideWeaverContext(callback, context);
-    context.deleteConfig(config[WEAVER_CONFIG]);
-    return result;
-  },
-  names,
-  getNamedType(name) {
-    return ref?.getNamedType(name);
-  },
-  memoNamedType(gqlType) {
-    return ref?.memoNamedType(gqlType) ?? gqlType;
-  },
-  GraphQLTypes: /* @__PURE__ */ new WeakMap(),
-  getGraphQLType(origin) {
-    return this.GraphQLTypes.get(origin);
-  },
-  memoGraphQLType(origin, gqlType) {
-    this.GraphQLTypes.set(origin, gqlType);
-    return gqlType;
-  }
+const weaverContext = {
+	get id() {
+		return ref?.id;
+	},
+	get loomObjectMap() {
+		return ref?.loomObjectMap;
+	},
+	get loomUnionMap() {
+		return ref?.loomUnionMap;
+	},
+	get inputMap() {
+		return ref?.inputMap;
+	},
+	get interfaceMap() {
+		return ref?.interfaceMap;
+	},
+	get configs() {
+		return ref?.configs;
+	},
+	get vendorWeavers() {
+		return ref?.vendorWeavers;
+	},
+	getConfig(key) {
+		return ref?.getConfig(key);
+	},
+	setConfig(config) {
+		ref?.setConfig(config);
+	},
+	deleteConfig(key) {
+		ref?.deleteConfig(key);
+	},
+	get value() {
+		return ref;
+	},
+	useConfig(config, callback) {
+		const context = weaverContext.value ?? initWeaverContext();
+		context.setConfig(config);
+		const result = provideWeaverContext(callback, context);
+		context.deleteConfig(config[WEAVER_CONFIG]);
+		return result;
+	},
+	names,
+	getNamedType(name) {
+		return ref?.getNamedType(name);
+	},
+	memoNamedType(gqlType) {
+		return ref?.memoNamedType(gqlType) ?? gqlType;
+	},
+	GraphQLTypes: /* @__PURE__ */ new WeakMap(),
+	getGraphQLType(origin) {
+		return this.GraphQLTypes.get(origin);
+	},
+	memoGraphQLType(origin, gqlType) {
+		this.GraphQLTypes.set(origin, gqlType);
+		return gqlType;
+	}
 };
 function provideWeaverContext(func, value) {
-  const lastRef = ref;
-  ref = value;
-  try {
-    return func();
-  } finally {
-    ref = lastRef;
-  }
+	const lastRef = ref;
+	ref = value;
+	try {
+		return func();
+	} finally {
+		ref = lastRef;
+	}
 }
 provideWeaverContext.inherit = (func) => {
-  const weaverContextRef = weaverContext.value;
-  return () => provideWeaverContext(func, weaverContextRef);
+	const weaverContextRef = weaverContext.value;
+	return () => provideWeaverContext(func, weaverContextRef);
 };
+/**
+* collect names for schemas
+* @param namesList - names to collect
+* @returns namesRecord
+*/
 function collectNames(...namesList) {
-  const namesRecord = {};
-  for (const namesItem of namesList) {
-    for (const [name, schema] of Object.entries(namesItem)) {
-      names.set(schema, name);
-      namesRecord[name] = schema;
-    }
-  }
-  return namesRecord;
+	const namesRecord = {};
+	for (const namesItem of namesList) for (const [name, schema] of Object.entries(namesItem)) {
+		names.set(schema, name);
+		namesRecord[name] = schema;
+	}
+	return namesRecord;
 }
+/**
+* collect name for schema
+* @param name - name for
+* @param schema - schema to be named
+* @returns schema
+*/
 function collectName(name, schema) {
-  names.set(schema, name);
-  return schema;
+	names.set(schema, name);
+	return schema;
 }
 
-// src/resolver/silk.ts
-function silk(type, validate = (value) => ({
-  value: value ?? void 0
-})) {
-  return {
-    [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
-    "~standard": {
-      version: 1,
-      vendor: "gqloom.silk",
-      validate
-    }
-  };
+//#endregion
+//#region src/resolver/silk.ts
+function silk(type, validate = (value) => ({ value: value ?? void 0 })) {
+	return {
+		[GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
+		"~standard": {
+			version: 1,
+			vendor: "gqloom.silk",
+			validate
+		}
+	};
 }
 silk.parse = parseSilk;
 silk.getType = getGraphQLType;
 silk.nonNull = nonNullSilk;
 silk.list = listSilk;
 silk.nullable = nullableSilk;
+/**
+* Non-nullable Silk.
+*/
 function nonNullSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof GraphQLNonNull) {
-        return originType;
-      } else {
-        return new GraphQLNonNull(originType);
-      }
-    }
-  };
+	return {
+		...origin,
+		[GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof GraphQLNonNull) return originType;
+			else return new GraphQLNonNull(originType);
+		}
+	};
 }
+/**
+* List Silk.
+*/
 function listSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      let originType = getGraphQLType(origin);
-      if (originType instanceof GraphQLNonNull && originType.ofType instanceof GraphQLList) {
-        originType = originType.ofType.ofType;
-      }
-      if (originType instanceof GraphQLList) {
-        originType = originType.ofType;
-      }
-      return new GraphQLNonNull(new GraphQLList(originType));
-    }
-  };
+	return {
+		...origin,
+		[GET_GRAPHQL_TYPE]: () => {
+			let originType = getGraphQLType(origin);
+			if (originType instanceof GraphQLNonNull && originType.ofType instanceof GraphQLList) originType = originType.ofType.ofType;
+			if (originType instanceof GraphQLList) originType = originType.ofType;
+			return new GraphQLNonNull(new GraphQLList(originType));
+		}
+	};
 }
+/**
+* Nullable Silk.
+*/
 function nullableSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof GraphQLNonNull) {
-        return originType.ofType;
-      } else {
-        return originType;
-      }
-    }
-  };
+	return {
+		...origin,
+		[GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof GraphQLNonNull) return originType.ofType;
+			else return originType;
+		}
+	};
 }
-function getGraphQLType(silk2) {
-  if (GET_GRAPHQL_TYPE in silk2 && silk2[GET_GRAPHQL_TYPE] != null)
-    return silk2[GET_GRAPHQL_TYPE]();
-  const vendorWeavers = weaverContext.vendorWeavers;
-  if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
-  const weaver = vendorWeavers.get(silk2["~standard"].vendor);
-  if (weaver == null)
-    throw new Error(
-      `Schema Weaver for ${silk2["~standard"].vendor} is not found`
-    );
-  return weaver.getGraphQLType(silk2);
+/**
+* Get GraphQL Output Type from Silk.
+* @param silk GraphQL Silk
+* @returns GraphQL Output Type
+*/
+function getGraphQLType(silk$1) {
+	if (GET_GRAPHQL_TYPE in silk$1 && silk$1[GET_GRAPHQL_TYPE] != null) return silk$1[GET_GRAPHQL_TYPE]();
+	const vendorWeavers = weaverContext.vendorWeavers;
+	if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
+	const weaver = vendorWeavers.get(silk$1["~standard"].vendor);
+	if (weaver == null) throw new Error(`Schema Weaver for ${silk$1["~standard"].vendor} is not found`);
+	return weaver.getGraphQLType(silk$1);
 }
-function parseSilk(silk2, input) {
-  return silk2["~standard"].validate(input);
+/**
+* Validate and transform input to output
+* @param silk silk GraphQL Silk
+* @param input
+* @returns output
+*/
+function parseSilk(silk$1, input) {
+	return silk$1["~standard"].validate(input);
 }
 function isSilk(target) {
-  if (typeof target !== "object") return false;
-  if (target == null) return false;
-  if (GET_GRAPHQL_TYPE in target) return true;
-  if (!("~standard" in target)) return false;
-  return "vendor" in target["~standard"] && typeof target["~standard"].vendor === "string" && "version" in target["~standard"] && typeof target["~standard"].version === "number";
+	if (typeof target !== "object") return false;
+	if (target == null) return false;
+	if (GET_GRAPHQL_TYPE in target) return true;
+	if (!("~standard" in target)) return false;
+	return "vendor" in target["~standard"] && typeof target["~standard"].vendor === "string" && "version" in target["~standard"] && typeof target["~standard"].version === "number";
 }
 
-// src/resolver/input.ts
-import { GraphQLError } from "graphql";
+//#endregion
+//#region src/resolver/input.ts
 function createInputParser(schema, value) {
-  let result;
-  const parse = async () => {
-    if (result !== void 0) return result;
-    result = await parseInputValue(schema, value);
-    return result;
-  };
-  Object.assign(parse, { schema, value });
-  Object.defineProperty(parse, "result", {
-    get: () => result,
-    set: (value2) => result = value2
-  });
-  Object.defineProperty(parse, "getResult", {
-    value: async () => getStandardValue(await parse())
-  });
-  Object.defineProperty(parse, "setResult", {
-    value: (value2) => result = { value: value2 }
-  });
-  Object.defineProperty(parse, "clearResult", {
-    value: () => result = void 0
-  });
-  return parse;
+	let result;
+	const parse = async () => {
+		if (result !== void 0) return result;
+		result = await parseInputValue(schema, value);
+		return result;
+	};
+	Object.assign(parse, {
+		schema,
+		value
+	});
+	Object.defineProperty(parse, "result", {
+		get: () => result,
+		set: (value$1) => result = value$1
+	});
+	Object.defineProperty(parse, "getResult", { value: async () => getStandardValue(await parse()) });
+	Object.defineProperty(parse, "setResult", { value: (value$1) => result = { value: value$1 } });
+	Object.defineProperty(parse, "clearResult", { value: () => result = void 0 });
+	return parse;
 }
 function parseInputValue(inputSchema, input) {
-  if (inputSchema === void 0) {
-    return { value: input };
-  }
-  if (isSilk(inputSchema)) {
-    return inputSchema["~standard"].validate(input);
-  }
-  return parseInputEntries(inputSchema, input);
+	if (inputSchema === void 0) return { value: input };
+	if (isSilk(inputSchema)) return inputSchema["~standard"].validate(input);
+	return parseInputEntries(inputSchema, input);
 }
 async function parseInputEntries(inputSchema, input = {}) {
-  const result = {};
-  const issues = [];
-  await Promise.all(
-    Object.entries(inputSchema).map(async ([key, value]) => {
-      const res = await value["~standard"].validate(input[key]);
-      if ("value" in res) {
-        result[key] = res.value;
-      }
-      if (res.issues) {
-        issues.push(...res.issues.slice());
-      }
-    })
-  );
-  return { value: result, ...issues.length > 0 ? { issues } : null };
+	const result = {};
+	const issues = [];
+	await Promise.all(Object.entries(inputSchema).map(async ([key, value]) => {
+		const res = await value["~standard"].validate(input[key]);
+		if ("value" in res) result[key] = res.value;
+		if (res.issues) issues.push(...res.issues.slice());
+	}));
+	return {
+		value: result,
+		...issues.length > 0 ? { issues } : null
+	};
 }
 function getStandardValue(result) {
-  if (result == null) return result;
-  const { issues } = result;
-  if (issues?.length) {
-    throw new GraphQLError(issues?.[0]?.message ?? "Invalid input", {
-      extensions: { issues }
-    });
-  }
-  if ("value" in result) return result.value;
-  else throw new GraphQLError("Invalid input");
+	if (result == null) return result;
+	const { issues } = result;
+	if (issues?.length) throw new GraphQLError(issues?.[0]?.message ?? "Invalid input", { extensions: { issues } });
+	if ("value" in result) return result.value;
+	else throw new GraphQLError("Invalid input");
 }
 
-// src/resolver/resolver-chain-factory.ts
-var BaseChainFactory = class _BaseChainFactory {
-  /**
-   * Creates a new instance of the chain factory
-   * @param options - Configuration options for the factory
-   */
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Returns the available methods for the chain factory
-   */
-  static methods() {
-    return {
-      description: _BaseChainFactory.prototype.description,
-      deprecationReason: _BaseChainFactory.prototype.deprecationReason,
-      extensions: _BaseChainFactory.prototype.extensions
-    };
-  }
-  /**
-   * Sets the description for the field
-   * @param description - The description text
-   */
-  description(description) {
-    return this.clone({ description });
-  }
-  /**
-   * Sets the deprecation reason for the field
-   * @param deprecationReason - The reason for deprecation
-   */
-  deprecationReason(deprecationReason) {
-    return this.clone({ deprecationReason });
-  }
-  /**
-   * Sets custom extensions for the field
-   * @param extensions - Custom extensions to add
-   */
-  extensions(extensions) {
-    return this.clone({ extensions });
-  }
-  /**
-   * Adds middleware functions to the field
-   * @param middlewares - Middleware functions to add
-   */
-  use(...middlewares) {
-    return this.clone({
-      middlewares: [...this.options?.middlewares ?? [], ...middlewares]
-    });
-  }
+//#endregion
+//#region src/resolver/resolver-chain-factory.ts
+/**
+* Base class for all chain factories
+* @template TField - The type of field being created
+*/
+var BaseChainFactory = class BaseChainFactory {
+	/**
+	* Returns the available methods for the chain factory
+	*/
+	static methods() {
+		return {
+			description: BaseChainFactory.prototype.description,
+			deprecationReason: BaseChainFactory.prototype.deprecationReason,
+			extensions: BaseChainFactory.prototype.extensions
+		};
+	}
+	/**
+	* Creates a new instance of the chain factory
+	* @param options - Configuration options for the factory
+	*/
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Sets the description for the field
+	* @param description - The description text
+	*/
+	description(description) {
+		return this.clone({ description });
+	}
+	/**
+	* Sets the deprecation reason for the field
+	* @param deprecationReason - The reason for deprecation
+	*/
+	deprecationReason(deprecationReason) {
+		return this.clone({ deprecationReason });
+	}
+	/**
+	* Sets custom extensions for the field
+	* @param extensions - Custom extensions to add
+	*/
+	extensions(extensions) {
+		return this.clone({ extensions });
+	}
+	/**
+	* Adds middleware functions to the field
+	* @param middlewares - Middleware functions to add
+	*/
+	use(...middlewares) {
+		return this.clone({ middlewares: [...this.options?.middlewares ?? [], ...middlewares] });
+	}
 };
-var FieldLoader = class _FieldLoader extends LoomDataLoader {
-  constructor(resolve) {
-    super();
-    this.resolve = resolve;
-  }
-  static getByPath(payload, resolve, getByPath = true) {
-    if (!payload) return new _FieldLoader(resolve);
-    const memoMap = getMemoizationMap(payload);
-    if (!getByPath) {
-      const loader = memoMap.get(resolve) ?? new _FieldLoader(resolve);
-      memoMap.set(resolve, loader);
-      return loader;
-    }
-    const fullPath = [];
-    let path = payload.info.path;
-    while (path) {
-      fullPath.push(path);
-      path = path.prev;
-    }
-    const pathKey = fullPath.reverse().map((p) => typeof p.key === "number" ? "[n]" : p.key).join(".");
-    const fieldLoaders = memoMap.get(resolve) ?? /* @__PURE__ */ new Map();
-    memoMap.set(resolve, fieldLoaders);
-    const fieldLoader = fieldLoaders.get(pathKey) ?? new _FieldLoader(resolve);
-    fieldLoaders.set(pathKey, fieldLoader);
-    return fieldLoader;
-  }
-  batchLoad(args) {
-    const parents = args.map(([parent]) => parent);
-    const payloads = args.map(([, , payload]) => payload);
-    return this.resolve(parents, args[0]?.[1], payloads);
-  }
+var FieldLoader = class FieldLoader extends LoomDataLoader {
+	static getByPath(payload, resolve, getByPath = true) {
+		if (!payload) return new FieldLoader(resolve);
+		const memoMap = getMemoizationMap(payload);
+		if (!getByPath) {
+			const loader = memoMap.get(resolve) ?? new FieldLoader(resolve);
+			memoMap.set(resolve, loader);
+			return loader;
+		}
+		const fullPath = [];
+		let path = payload.info.path;
+		while (path) {
+			fullPath.push(path);
+			path = path.prev;
+		}
+		const pathKey = fullPath.reverse().map((p) => typeof p.key === "number" ? "[n]" : p.key).join(".");
+		const fieldLoaders = memoMap.get(resolve) ?? /* @__PURE__ */ new Map();
+		memoMap.set(resolve, fieldLoaders);
+		const fieldLoader = fieldLoaders.get(pathKey) ?? new FieldLoader(resolve);
+		fieldLoaders.set(pathKey, fieldLoader);
+		return fieldLoader;
+	}
+	constructor(resolve) {
+		super();
+		this.resolve = resolve;
+	}
+	batchLoad(args) {
+		const parents = args.map(([parent]) => parent);
+		const payloads = args.map(([, , payload]) => payload);
+		return this.resolve(parents, args[0]?.[1], payloads);
+	}
 };
-var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
-  /**
-   * Returns the available methods for the field chain factory
-   */
-  static methods() {
-    return {
-      ...BaseChainFactory.methods(),
-      output: _FieldChainFactory.prototype.output,
-      input: _FieldChainFactory.prototype.input,
-      resolve: _FieldChainFactory.prototype.resolve,
-      clone: _FieldChainFactory.prototype.clone
-    };
-  }
-  /**
-   * Creates a clone of the current factory with new options
-   * @param options - New options to apply to the clone
-   */
-  clone(options) {
-    return new _FieldChainFactory({ ...this.options, ...options });
-  }
-  /**
-   * Sets the output type for the field
-   * @template TOutputNew - The new output type
-   * @param output - The output type definition
-   */
-  output(output) {
-    return new _FieldChainFactory({ ...this.options, output });
-  }
-  /**
-   * Sets the input type for the field
-   * @template TInputNew - The new input type
-   * @param input - The input type definition
-   */
-  input(input) {
-    return new _FieldChainFactory({ ...this.options, input });
-  }
-  /**
-   * Specifies the dependencies for the field
-   * @template TDependencies - The dependencies type
-   * @param dependencies - The dependencies to add
-   */
-  derivedFrom(...dependencies) {
-    return this.clone({ dependencies });
-  }
-  /**
-   * Sets the resolve function for the field
-   * @template TParent - The parent type
-   * @param resolve - The resolve function
-   */
-  resolve(resolve) {
-    if (!this.options?.output) throw new Error("Output is required");
-    return createField(this.options.output, {
-      ...this.options,
-      resolve
-    });
-  }
-  /**
-   * Creates a field resolver that uses DataLoader for batch loading data.
-   * This method is particularly useful for optimizing performance when dealing with multiple data requests
-   * by batching them together and handling caching automatically.
-   *
-   * @template TParent - The parent type that extends GraphQLSilk
-   * @param resolve - A function that handles batch loading of data.
-   * @returns A GraphQL field resolver that implements batch loading
-   */
-  load(resolve) {
-    if (!this.options?.output) throw new Error("Output is required");
-    return createField(this.options.output, {
-      ...this.options,
-      resolve: (parent, input, payload) => {
-        const loader = FieldLoader.getByPath(
-          payload,
-          resolve,
-          this.options?.input != null
-        );
-        return loader.load([parent, input, payload]);
-      }
-    });
-  }
+/**
+* Factory for creating field resolvers with chainable configuration
+* @template TOutput - The output type of the field
+* @template TInput - The input type of the field
+* @template TDependencies - The dependencies of the field
+*/
+var FieldChainFactory = class FieldChainFactory extends BaseChainFactory {
+	/**
+	* Returns the available methods for the field chain factory
+	*/
+	static methods() {
+		return {
+			...BaseChainFactory.methods(),
+			output: FieldChainFactory.prototype.output,
+			input: FieldChainFactory.prototype.input,
+			resolve: FieldChainFactory.prototype.resolve,
+			clone: FieldChainFactory.prototype.clone
+		};
+	}
+	/**
+	* Creates a clone of the current factory with new options
+	* @param options - New options to apply to the clone
+	*/
+	clone(options) {
+		return new FieldChainFactory({
+			...this.options,
+			...options
+		});
+	}
+	/**
+	* Sets the output type for the field
+	* @template TOutputNew - The new output type
+	* @param output - The output type definition
+	*/
+	output(output) {
+		return new FieldChainFactory({
+			...this.options,
+			output
+		});
+	}
+	/**
+	* Sets the input type for the field
+	* @template TInputNew - The new input type
+	* @param input - The input type definition
+	*/
+	input(input) {
+		return new FieldChainFactory({
+			...this.options,
+			input
+		});
+	}
+	/**
+	* Specifies the dependencies for the field
+	* @template TDependencies - The dependencies type
+	* @param dependencies - The dependencies to add
+	*/
+	derivedFrom(...dependencies) {
+		return this.clone({ dependencies });
+	}
+	/**
+	* Sets the resolve function for the field
+	* @template TParent - The parent type
+	* @param resolve - The resolve function
+	*/
+	resolve(resolve) {
+		if (!this.options?.output) throw new Error("Output is required");
+		return createField(this.options.output, {
+			...this.options,
+			resolve
+		});
+	}
+	/**
+	* Creates a field resolver that uses DataLoader for batch loading data.
+	* This method is particularly useful for optimizing performance when dealing with multiple data requests
+	* by batching them together and handling caching automatically.
+	*
+	* @template TParent - The parent type that extends GraphQLSilk
+	* @param resolve - A function that handles batch loading of data.
+	* @returns A GraphQL field resolver that implements batch loading
+	*/
+	load(resolve) {
+		if (!this.options?.output) throw new Error("Output is required");
+		return createField(this.options.output, {
+			...this.options,
+			resolve: (parent, input, payload) => {
+				const loader = FieldLoader.getByPath(payload, resolve, this.options?.input != null);
+				return loader.load([
+					parent,
+					input,
+					payload
+				]);
+			}
+		});
+	}
 };
-var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
-  /**
-   * Returns the available methods for the query chain factory
-   * @returns An object containing all available methods
-   */
-  static methods() {
-    return {
-      ...BaseChainFactory.methods(),
-      output: _QueryChainFactory.prototype.output,
-      input: _QueryChainFactory.prototype.input,
-      resolve: _QueryChainFactory.prototype.resolve,
-      clone: _QueryChainFactory.prototype.clone
-    };
-  }
-  /**
-   * Creates a clone of the current factory with new options
-   * @param options - New options to apply to the clone
-   * @returns A new instance of QueryChainFactory with the updated options
-   */
-  clone(options) {
-    return new _QueryChainFactory({ ...this.options, ...options });
-  }
-  /**
-   * Sets the output type for the query
-   * @template TOutputNew - The new output type
-   * @param output - The output type definition
-   * @returns A new QueryChainFactory instance with the updated output type
-   */
-  output(output) {
-    return new _QueryChainFactory({ ...this.options, output });
-  }
-  /**
-   * Sets the input type for the query
-   * @template TInputNew - The new input type
-   * @param input - The input type definition
-   * @returns A new QueryChainFactory instance with the updated input type
-   */
-  input(input) {
-    return new _QueryChainFactory({ ...this.options, input });
-  }
-  /**
-   * Sets the resolve function for the query
-   * @param resolve - The resolve function that processes the input and returns the output
-   * @returns A GraphQL query resolver
-   * @throws {Error} If output type is not set
-   */
-  resolve(resolve) {
-    if (!this.options?.output) throw new Error("Output is required");
-    return createQuery(this.options.output, {
-      ...this.options,
-      resolve
-    });
-  }
+/**
+* Factory for creating query resolvers with chainable configuration
+* @template TOutput - The output type of the query
+* @template TInput - The input type of the query
+*/
+var QueryChainFactory = class QueryChainFactory extends BaseChainFactory {
+	/**
+	* Returns the available methods for the query chain factory
+	* @returns An object containing all available methods
+	*/
+	static methods() {
+		return {
+			...BaseChainFactory.methods(),
+			output: QueryChainFactory.prototype.output,
+			input: QueryChainFactory.prototype.input,
+			resolve: QueryChainFactory.prototype.resolve,
+			clone: QueryChainFactory.prototype.clone
+		};
+	}
+	/**
+	* Creates a clone of the current factory with new options
+	* @param options - New options to apply to the clone
+	* @returns A new instance of QueryChainFactory with the updated options
+	*/
+	clone(options) {
+		return new QueryChainFactory({
+			...this.options,
+			...options
+		});
+	}
+	/**
+	* Sets the output type for the query
+	* @template TOutputNew - The new output type
+	* @param output - The output type definition
+	* @returns A new QueryChainFactory instance with the updated output type
+	*/
+	output(output) {
+		return new QueryChainFactory({
+			...this.options,
+			output
+		});
+	}
+	/**
+	* Sets the input type for the query
+	* @template TInputNew - The new input type
+	* @param input - The input type definition
+	* @returns A new QueryChainFactory instance with the updated input type
+	*/
+	input(input) {
+		return new QueryChainFactory({
+			...this.options,
+			input
+		});
+	}
+	/**
+	* Sets the resolve function for the query
+	* @param resolve - The resolve function that processes the input and returns the output
+	* @returns A GraphQL query resolver
+	* @throws {Error} If output type is not set
+	*/
+	resolve(resolve) {
+		if (!this.options?.output) throw new Error("Output is required");
+		return createQuery(this.options.output, {
+			...this.options,
+			resolve
+		});
+	}
 };
-var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory {
-  /**
-   * Returns the available methods for the mutation chain factory
-   * @returns An object containing all available methods
-   */
-  static methods() {
-    return {
-      ...BaseChainFactory.methods(),
-      output: _MutationChainFactory.prototype.output,
-      input: _MutationChainFactory.prototype.input,
-      resolve: _MutationChainFactory.prototype.resolve,
-      clone: _MutationChainFactory.prototype.clone
-    };
-  }
-  /**
-   * Creates a clone of the current factory with new options
-   * @param options - New options to apply to the clone
-   * @returns A new instance of MutationChainFactory with the updated options
-   */
-  clone(options) {
-    return new _MutationChainFactory({ ...this.options, ...options });
-  }
-  /**
-   * Sets the output type for the mutation
-   * @template TOutputNew - The new output type
-   * @param output - The output type definition
-   * @returns A new MutationChainFactory instance with the updated output type
-   */
-  output(output) {
-    return new _MutationChainFactory({ ...this.options, output });
-  }
-  /**
-   * Sets the input type for the mutation
-   * @template TInputNew - The new input type
-   * @param input - The input type definition
-   * @returns A new MutationChainFactory instance with the updated input type
-   */
-  input(input) {
-    return new _MutationChainFactory({ ...this.options, input });
-  }
-  /**
-   * Sets the resolve function for the mutation
-   * @param resolve - The resolve function that processes the input and returns the output
-   * @returns A GraphQL mutation resolver
-   * @throws {Error} If output type is not set
-   */
-  resolve(resolve) {
-    if (!this.options?.output) throw new Error("Output is required");
-    return createMutation(this.options.output, {
-      ...this.options,
-      resolve
-    });
-  }
+/**
+* Factory for creating mutation resolvers with chainable configuration
+* @template TOutput - The output type of the mutation
+* @template TInput - The input type of the mutation
+*/
+var MutationChainFactory = class MutationChainFactory extends BaseChainFactory {
+	/**
+	* Returns the available methods for the mutation chain factory
+	* @returns An object containing all available methods
+	*/
+	static methods() {
+		return {
+			...BaseChainFactory.methods(),
+			output: MutationChainFactory.prototype.output,
+			input: MutationChainFactory.prototype.input,
+			resolve: MutationChainFactory.prototype.resolve,
+			clone: MutationChainFactory.prototype.clone
+		};
+	}
+	/**
+	* Creates a clone of the current factory with new options
+	* @param options - New options to apply to the clone
+	* @returns A new instance of MutationChainFactory with the updated options
+	*/
+	clone(options) {
+		return new MutationChainFactory({
+			...this.options,
+			...options
+		});
+	}
+	/**
+	* Sets the output type for the mutation
+	* @template TOutputNew - The new output type
+	* @param output - The output type definition
+	* @returns A new MutationChainFactory instance with the updated output type
+	*/
+	output(output) {
+		return new MutationChainFactory({
+			...this.options,
+			output
+		});
+	}
+	/**
+	* Sets the input type for the mutation
+	* @template TInputNew - The new input type
+	* @param input - The input type definition
+	* @returns A new MutationChainFactory instance with the updated input type
+	*/
+	input(input) {
+		return new MutationChainFactory({
+			...this.options,
+			input
+		});
+	}
+	/**
+	* Sets the resolve function for the mutation
+	* @param resolve - The resolve function that processes the input and returns the output
+	* @returns A GraphQL mutation resolver
+	* @throws {Error} If output type is not set
+	*/
+	resolve(resolve) {
+		if (!this.options?.output) throw new Error("Output is required");
+		return createMutation(this.options.output, {
+			...this.options,
+			resolve
+		});
+	}
 };
-var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChainFactory {
-  /**
-   * Returns the available methods for the subscription chain factory
-   * @returns An object containing all available methods
-   */
-  static methods() {
-    return {
-      ...BaseChainFactory.methods(),
-      output: _SubscriptionChainFactory.prototype.output,
-      input: _SubscriptionChainFactory.prototype.input,
-      subscribe: _SubscriptionChainFactory.prototype.subscribe,
-      clone: _SubscriptionChainFactory.prototype.clone
-    };
-  }
-  /**
-   * Creates a clone of the current factory with new options
-   * @param options - New options to apply to the clone
-   * @returns A new instance of SubscriptionChainFactory with the updated options
-   */
-  clone(options) {
-    return new _SubscriptionChainFactory({ ...this.options, ...options });
-  }
-  /**
-   * Sets the output type for the subscription
-   * @template TOutputNew - The new output type
-   * @param output - The output type definition
-   * @returns A new SubscriptionChainFactory instance with the updated output type
-   */
-  output(output) {
-    return new _SubscriptionChainFactory({ ...this.options, output });
-  }
-  /**
-   * Sets the input type for the subscription
-   * @template TInputNew - The new input type
-   * @param input - The input type definition
-   * @returns A new SubscriptionChainFactory instance with the updated input type
-   */
-  input(input) {
-    return new _SubscriptionChainFactory({ ...this.options, input });
-  }
-  /**
-   * Sets the subscribe function for the subscription
-   * @template TValue - The value type of the subscription
-   * @param subscribe - The subscribe function that returns an AsyncIterator
-   * @returns A subscription resolver that can be further configured with a resolve function
-   * @throws {Error} If output type is not set
-   */
-  subscribe(subscribe) {
-    const options = this.options;
-    const output = this.options?.output;
-    if (!output) throw new Error("Output is required");
-    const subscription2 = createSubscription(output, {
-      ...options,
-      subscribe
-    });
-    const subscriptionResolve = subscription2["~meta"].resolve;
-    const resolve = (...args) => {
-      if (args.length === 1 && typeof args[0] === "function") {
-        return createSubscription(output, {
-          ...options,
-          resolve: args[0],
-          subscribe
-        });
-      }
-      return subscriptionResolve(...args);
-    };
-    return Object.assign(subscription2, { resolve });
-  }
+/**
+* Factory for creating subscription resolvers with chainable configuration
+* @template TOutput - The output type of the subscription
+* @template TInput - The input type of the subscription
+*/
+var SubscriptionChainFactory = class SubscriptionChainFactory extends BaseChainFactory {
+	/**
+	* Returns the available methods for the subscription chain factory
+	* @returns An object containing all available methods
+	*/
+	static methods() {
+		return {
+			...BaseChainFactory.methods(),
+			output: SubscriptionChainFactory.prototype.output,
+			input: SubscriptionChainFactory.prototype.input,
+			subscribe: SubscriptionChainFactory.prototype.subscribe,
+			clone: SubscriptionChainFactory.prototype.clone
+		};
+	}
+	/**
+	* Creates a clone of the current factory with new options
+	* @param options - New options to apply to the clone
+	* @returns A new instance of SubscriptionChainFactory with the updated options
+	*/
+	clone(options) {
+		return new SubscriptionChainFactory({
+			...this.options,
+			...options
+		});
+	}
+	/**
+	* Sets the output type for the subscription
+	* @template TOutputNew - The new output type
+	* @param output - The output type definition
+	* @returns A new SubscriptionChainFactory instance with the updated output type
+	*/
+	output(output) {
+		return new SubscriptionChainFactory({
+			...this.options,
+			output
+		});
+	}
+	/**
+	* Sets the input type for the subscription
+	* @template TInputNew - The new input type
+	* @param input - The input type definition
+	* @returns A new SubscriptionChainFactory instance with the updated input type
+	*/
+	input(input) {
+		return new SubscriptionChainFactory({
+			...this.options,
+			input
+		});
+	}
+	/**
+	* Sets the subscribe function for the subscription
+	* @template TValue - The value type of the subscription
+	* @param subscribe - The subscribe function that returns an AsyncIterator
+	* @returns A subscription resolver that can be further configured with a resolve function
+	* @throws {Error} If output type is not set
+	*/
+	subscribe(subscribe) {
+		const options = this.options;
+		const output = this.options?.output;
+		if (!output) throw new Error("Output is required");
+		const subscription$1 = createSubscription(output, {
+			...options,
+			subscribe
+		});
+		const subscriptionResolve = subscription$1["~meta"].resolve;
+		const resolve = (...args) => {
+			if (args.length === 1 && typeof args[0] === "function") return createSubscription(output, {
+				...options,
+				resolve: args[0],
+				subscribe
+			});
+			return subscriptionResolve(...args);
+		};
+		return Object.assign(subscription$1, { resolve });
+	}
 };
-var QueryFactoryWithResolve = class _QueryFactoryWithResolve extends BaseChainFactory {
-  constructor(outputSilk, options) {
-    super(options);
-    this.outputSilk = outputSilk;
-    this.options = options;
-  }
-  get "~meta"() {
-    return loom.query(this.outputSilk, this.options)["~meta"];
-  }
-  clone(options) {
-    return new _QueryFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      ...options
-    });
-  }
-  input(input) {
-    return new _QueryFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      input
-    });
-  }
-  output(output, transform) {
-    return new _QueryFactoryWithResolve(output, {
-      ...this.options,
-      middlewares: [
-        ...this.options.middlewares ?? [],
-        async (next) => transform(await next())
-      ]
-    });
-  }
+var QueryFactoryWithResolve = class QueryFactoryWithResolve extends BaseChainFactory {
+	get "~meta"() {
+		return loom.query(this.outputSilk, this.options)["~meta"];
+	}
+	constructor(outputSilk, options) {
+		super(options);
+		this.outputSilk = outputSilk;
+		this.options = options;
+	}
+	clone(options) {
+		return new QueryFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			...options
+		});
+	}
+	input(input) {
+		return new QueryFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			input
+		});
+	}
+	output(output, transform) {
+		return new QueryFactoryWithResolve(output, {
+			...this.options,
+			middlewares: [...this.options.middlewares ?? [], async (next) => transform(await next())]
+		});
+	}
 };
-var MutationFactoryWithResolve = class _MutationFactoryWithResolve extends BaseChainFactory {
-  constructor(outputSilk, options) {
-    super(options);
-    this.outputSilk = outputSilk;
-    this.options = options;
-  }
-  get "~meta"() {
-    return loom.mutation(this.outputSilk, this.options)["~meta"];
-  }
-  clone(options) {
-    return new _MutationFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      ...options
-    });
-  }
-  input(input) {
-    return new _MutationFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      input
-    });
-  }
-  output(output, transform) {
-    return new _MutationFactoryWithResolve(output, {
-      ...this.options,
-      middlewares: [
-        ...this.options.middlewares ?? [],
-        async (next) => transform(await next())
-      ]
-    });
-  }
+var MutationFactoryWithResolve = class MutationFactoryWithResolve extends BaseChainFactory {
+	get "~meta"() {
+		return loom.mutation(this.outputSilk, this.options)["~meta"];
+	}
+	constructor(outputSilk, options) {
+		super(options);
+		this.outputSilk = outputSilk;
+		this.options = options;
+	}
+	clone(options) {
+		return new MutationFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			...options
+		});
+	}
+	input(input) {
+		return new MutationFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			input
+		});
+	}
+	output(output, transform) {
+		return new MutationFactoryWithResolve(output, {
+			...this.options,
+			middlewares: [...this.options.middlewares ?? [], async (next) => transform(await next())]
+		});
+	}
 };
-var FieldFactoryWithResolve = class _FieldFactoryWithResolve extends BaseChainFactory {
-  constructor(outputSilk, options) {
-    super(options);
-    this.outputSilk = outputSilk;
-    this.options = options;
-  }
-  get "~meta"() {
-    return loom.field(
-      this.outputSilk,
-      this.options
-    )["~meta"];
-  }
-  clone(options) {
-    return new _FieldFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      ...options
-    });
-  }
-  input(input) {
-    return new _FieldFactoryWithResolve(this.outputSilk, {
-      ...this.options,
-      input
-    });
-  }
-  output(output, transform) {
-    return new _FieldFactoryWithResolve(output, {
-      ...this.options,
-      middlewares: [
-        ...this.options.middlewares ?? [],
-        async (next) => transform(await next())
-      ]
-    });
-  }
+var FieldFactoryWithResolve = class FieldFactoryWithResolve extends BaseChainFactory {
+	get "~meta"() {
+		return loom.field(this.outputSilk, this.options)["~meta"];
+	}
+	constructor(outputSilk, options) {
+		super(options);
+		this.outputSilk = outputSilk;
+		this.options = options;
+	}
+	clone(options) {
+		return new FieldFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			...options
+		});
+	}
+	input(input) {
+		return new FieldFactoryWithResolve(this.outputSilk, {
+			...this.options,
+			input
+		});
+	}
+	output(output, transform) {
+		return new FieldFactoryWithResolve(output, {
+			...this.options,
+			middlewares: [...this.options.middlewares ?? [], async (next) => transform(await next())]
+		});
+	}
 };
 
-// src/resolver/resolver.ts
-var createQuery = (output, resolveOrOptions) => {
-  if (resolveOrOptions == null) {
-    return new QueryChainFactory({ output });
-  }
-  const options = getOperationOptions(resolveOrOptions);
-  return meta({
-    ...getFieldOptions(options),
-    input: options.input,
-    output,
-    resolve: options.resolve,
-    middlewares: options.middlewares,
-    operation: "query"
-  });
+//#endregion
+//#region src/resolver/resolver.ts
+/**
+* Creates a GraphQL query resolver
+* @param output - The output type definition for the query
+* @param resolveOrOptions - Either a resolve function or options object
+* @returns A GraphQL query resolver
+*/
+const createQuery = (output, resolveOrOptions) => {
+	if (resolveOrOptions == null) return new QueryChainFactory({ output });
+	const options = getOperationOptions(resolveOrOptions);
+	return meta({
+		...getFieldOptions(options),
+		input: options.input,
+		output,
+		resolve: options.resolve,
+		middlewares: options.middlewares,
+		operation: "query"
+	});
 };
-var query = Object.assign(
-  createQuery,
-  QueryChainFactory.methods()
-);
-var createMutation = (output, resolveOrOptions) => {
-  if (resolveOrOptions == null) {
-    return new MutationChainFactory({ output });
-  }
-  const options = getOperationOptions(resolveOrOptions);
-  return meta({
-    ...getFieldOptions(options),
-    input: options.input,
-    output,
-    resolve: options.resolve,
-    middlewares: options.middlewares,
-    operation: "mutation"
-  });
+/**
+* Factory function for creating GraphQL queries with chainable configuration
+*/
+const query = Object.assign(createQuery, QueryChainFactory.methods());
+/**
+* Creates a GraphQL mutation resolver
+* @param output - The output type definition for the mutation
+* @param resolveOrOptions - Either a resolve function or options object
+* @returns A GraphQL mutation resolver
+*/
+const createMutation = (output, resolveOrOptions) => {
+	if (resolveOrOptions == null) return new MutationChainFactory({ output });
+	const options = getOperationOptions(resolveOrOptions);
+	return meta({
+		...getFieldOptions(options),
+		input: options.input,
+		output,
+		resolve: options.resolve,
+		middlewares: options.middlewares,
+		operation: "mutation"
+	});
 };
-var mutation = Object.assign(
-  createMutation,
-  MutationChainFactory.methods()
-);
-var createField = (output, resolveOrOptions) => {
-  if (resolveOrOptions == null) {
-    return new FieldChainFactory({ output });
-  }
-  const options = getOperationOptions(resolveOrOptions);
-  return meta({
-    ...getFieldOptions(options, {
-      [DERIVED_DEPENDENCIES]: options.dependencies
-    }),
-    input: options.input,
-    dependencies: options.dependencies,
-    output,
-    resolve: options.resolve,
-    middlewares: options.middlewares,
-    operation: "field"
-  });
+/**
+* Factory function for creating GraphQL mutations with chainable configuration
+*/
+const mutation = Object.assign(createMutation, MutationChainFactory.methods());
+/**
+* Creates a GraphQL field resolver
+* @param output - The output type definition for the field
+* @param resolveOrOptions - Either a resolve function or options object
+* @returns A GraphQL field resolver
+*/
+const createField = (output, resolveOrOptions) => {
+	if (resolveOrOptions == null) return new FieldChainFactory({ output });
+	const options = getOperationOptions(resolveOrOptions);
+	return meta({
+		...getFieldOptions(options, { [DERIVED_DEPENDENCIES]: options.dependencies }),
+		input: options.input,
+		dependencies: options.dependencies,
+		output,
+		resolve: options.resolve,
+		middlewares: options.middlewares,
+		operation: "field"
+	});
 };
-var field = Object.assign(
-  createField,
-  { hidden: FIELD_HIDDEN },
-  FieldChainFactory.methods()
-);
-var defaultSubscriptionResolve = (source) => source;
+/**
+* Factory function for creating GraphQL fields with chainable configuration
+*/
+const field = Object.assign(createField, { hidden: FIELD_HIDDEN }, FieldChainFactory.methods());
+/**
+* Default subscription resolver that returns the source value
+* @param source - The source value to resolve
+*/
+const defaultSubscriptionResolve = (source) => source;
+/**
+* Creates a GraphQL subscription resolver
+* @param output - The output type definition for the subscription
+* @param subscribeOrOptions - Optional subscribe function or options object
+* @returns A GraphQL subscription resolver or chain factory
+*/
 function createSubscription(output, subscribeOrOptions) {
-  if (subscribeOrOptions == null) {
-    return new SubscriptionChainFactory({ output });
-  }
-  const options = getSubscriptionOptions(subscribeOrOptions);
-  return meta({
-    ...getFieldOptions(options),
-    input: options.input,
-    output,
-    subscribe: options.subscribe,
-    resolve: options.resolve ?? defaultSubscriptionResolve,
-    middlewares: options.middlewares,
-    operation: "subscription"
-  });
+	if (subscribeOrOptions == null) return new SubscriptionChainFactory({ output });
+	const options = getSubscriptionOptions(subscribeOrOptions);
+	return meta({
+		...getFieldOptions(options),
+		input: options.input,
+		output,
+		subscribe: options.subscribe,
+		resolve: options.resolve ?? defaultSubscriptionResolve,
+		middlewares: options.middlewares,
+		operation: "subscription"
+	});
 }
-var subscription = Object.assign(
-  createSubscription,
-  SubscriptionChainFactory.methods()
-);
-var resolver = Object.assign(
-  (operations, options) => new ChainResolver(operations, options),
-  {
-    of: (parent, operations, options) => new ObjectChainResolver(
-      parent,
-      operations,
-      options
-    )
-  }
-);
-var loom = {
-  query,
-  resolver,
-  field,
-  subscription,
-  mutation
+/**
+* Factory function for creating GraphQL subscriptions with chainable configuration
+*/
+const subscription = Object.assign(createSubscription, SubscriptionChainFactory.methods());
+const resolver = Object.assign(((operations, options) => new ChainResolver(operations, options)), { of: ((parent, operations, options) => new ObjectChainResolver(parent, operations, options)) });
+/**
+* Collection of factory functions for creating GraphQL operations
+*/
+const loom = {
+	query,
+	resolver,
+	field,
+	subscription,
+	mutation
 };
+/**
+* Base class for chain resolvers
+* @template TFields - The fields or operations to resolve
+*/
 var ChainResolver = class {
-  meta;
-  /**
-   * Creates a new chain resolver
-   * @param fields - The fields or operations to resolve
-   * @param options - Optional resolver options
-   */
-  constructor(fields, options) {
-    this.meta = {
-      [IS_RESOLVER]: true,
-      fields,
-      options
-    };
-  }
-  /**
-   * Gets the metadata for the resolver
-   */
-  get "~meta"() {
-    return this.meta;
-  }
-  /**
-   * Adds middleware functions to the resolver
-   * @param middlewares - The middleware functions to add
-   */
-  use(...middlewares) {
-    this.meta.options ??= {};
-    this.meta.options.middlewares ??= [];
-    this.meta.options.middlewares.push(...middlewares);
-    return this;
-  }
-  toExecutor(...middlewares) {
-    const executor = mapValue(
-      this["~meta"].fields,
-      (field2) => this.toExecutorOperation(field2, middlewares) ?? mapValue.SKIP
-    );
-    return executor;
-  }
-  toExecutorOperation(field2, executorMiddlewares) {
-    if (field2 === FIELD_HIDDEN || field2["~meta"].operation === "subscription") {
-      return void 0;
-    }
-    const operation = field2["~meta"].operation;
-    const middlewares = filterMiddlewares(
-      operation,
-      executorMiddlewares,
-      this.meta.options?.middlewares,
-      field2["~meta"].middlewares
-    );
-    if (field2["~meta"].operation === "field") {
-      const resolve = field2["~meta"].resolve;
-      return (parent, args, payload) => {
-        const parseInput = createInputParser(field2["~meta"].input, args);
-        return applyMiddlewares(
-          {
-            outputSilk: field2["~meta"].output,
-            parent,
-            payload,
-            parseInput,
-            operation
-          },
-          async () => resolve(parent, await parseInput.getResult(), payload),
-          middlewares
-        );
-      };
-    } else {
-      const resolve = field2["~meta"].resolve;
-      return (args, payload) => {
-        const parseInput = createInputParser(field2["~meta"].input, args);
-        return applyMiddlewares(
-          {
-            outputSilk: field2["~meta"].output,
-            parent: void 0,
-            payload,
-            parseInput,
-            operation
-          },
-          async () => resolve(await parseInput.getResult(), payload),
-          middlewares
-        );
-      };
-    }
-  }
+	meta;
+	/**
+	* Creates a new chain resolver
+	* @param fields - The fields or operations to resolve
+	* @param options - Optional resolver options
+	*/
+	constructor(fields, options) {
+		this.meta = {
+			[IS_RESOLVER]: true,
+			fields,
+			options
+		};
+	}
+	/**
+	* Gets the metadata for the resolver
+	*/
+	get "~meta"() {
+		return this.meta;
+	}
+	/**
+	* Adds middleware functions to the resolver
+	* @param middlewares - The middleware functions to add
+	*/
+	use(...middlewares) {
+		this.meta.options ??= {};
+		this.meta.options.middlewares ??= [];
+		this.meta.options.middlewares.push(...middlewares);
+		return this;
+	}
+	toExecutor(...middlewares) {
+		const executor = mapValue(this["~meta"].fields, (field$1) => this.toExecutorOperation(field$1, middlewares) ?? mapValue.SKIP);
+		return executor;
+	}
+	toExecutorOperation(field$1, executorMiddlewares) {
+		if (field$1 === FIELD_HIDDEN || field$1["~meta"].operation === "subscription") return void 0;
+		const operation = field$1["~meta"].operation;
+		const middlewares = filterMiddlewares(operation, executorMiddlewares, this.meta.options?.middlewares, field$1["~meta"].middlewares);
+		if (field$1["~meta"].operation === "field") {
+			const resolve = field$1["~meta"].resolve;
+			return (parent, args, payload) => {
+				const parseInput = createInputParser(field$1["~meta"].input, args);
+				return applyMiddlewares({
+					outputSilk: field$1["~meta"].output,
+					parent,
+					payload,
+					parseInput,
+					operation
+				}, async () => resolve(parent, await parseInput.getResult(), payload), middlewares);
+			};
+		} else {
+			const resolve = field$1["~meta"].resolve;
+			return (args, payload) => {
+				const parseInput = createInputParser(field$1["~meta"].input, args);
+				return applyMiddlewares({
+					outputSilk: field$1["~meta"].output,
+					parent: void 0,
+					payload,
+					parseInput,
+					operation
+				}, async () => resolve(await parseInput.getResult(), payload), middlewares);
+			};
+		}
+	}
 };
+/**
+* Class for resolving object types
+* @template TParent - The parent type
+* @template TFields - The fields to resolve
+*/
 var ObjectChainResolver = class extends ChainResolver {
-  meta;
-  /**
-   * Creates a new object chain resolver
-   * @param parent - The parent type definition
-   * @param fields - The fields to resolve
-   * @param options - Optional resolver options
-   */
-  constructor(parent, fields, options) {
-    super(fields, options);
-    this.meta = {
-      [IS_RESOLVER]: true,
-      fields,
-      parent,
-      options
-    };
-  }
-  /**
-   * Gets the metadata for the resolver
-   */
-  get "~meta"() {
-    return super["~meta"];
-  }
-  /**
-   * Sets custom extensions for the resolver
-   * @param extensions - The extensions to add
-   */
-  extensions(extensions) {
-    this.meta.options ??= {};
-    this.meta.options.extensions ??= {};
-    this.meta.options.extensions = {
-      ...this.meta.options.extensions,
-      ...extensions
-    };
-    return this;
-  }
+	meta;
+	/**
+	* Creates a new object chain resolver
+	* @param parent - The parent type definition
+	* @param fields - The fields to resolve
+	* @param options - Optional resolver options
+	*/
+	constructor(parent, fields, options) {
+		super(fields, options);
+		this.meta = {
+			[IS_RESOLVER]: true,
+			fields,
+			parent,
+			options
+		};
+	}
+	/**
+	* Gets the metadata for the resolver
+	*/
+	get "~meta"() {
+		return super["~meta"];
+	}
+	/**
+	* Sets custom extensions for the resolver
+	* @param extensions - The extensions to add
+	*/
+	extensions(extensions) {
+		this.meta.options ??= {};
+		this.meta.options.extensions ??= {};
+		this.meta.options.extensions = {
+			...this.meta.options.extensions,
+			...extensions
+		};
+		return this;
+	}
 };
 
-// src/schema/object.ts
-import {
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
-  GraphQLObjectType,
-  GraphQLUnionType,
-  assertName,
-  isListType as isListType2,
-  isNonNullType as isNonNullType2,
-  isObjectType as isObjectType3,
-  isUnionType as isUnionType3,
-  resolveObjMapThunk
-} from "graphql";
-
-// src/schema/input.ts
-import {
-  GraphQLInputObjectType,
-  GraphQLList as GraphQLList2,
-  GraphQLNonNull as GraphQLNonNull2,
-  isInputObjectType,
-  isInterfaceType,
-  isListType,
-  isNonNullType,
-  isObjectType as isObjectType2,
-  isUnionType as isUnionType2
-} from "graphql";
+//#endregion
+//#region src/schema/input.ts
 function inputToArgs(input, options) {
-  if (input === void 0) return void 0;
-  if (isSilk(input)) {
-    let inputType = getGraphQLType(input);
-    if (isNonNullType(inputType)) inputType = inputType.ofType;
-    if (isObjectType2(inputType)) {
-      return mapValue(inputType.toConfig().fields, (it, key) => {
-        let fieldName;
-        if (options?.fieldName) {
-          fieldName = `${pascalCase(options.fieldName)}${pascalCase(key)}`;
-        }
-        return toInputFieldConfig(it, { fieldName });
-      });
-    }
-    throw new Error(`Cannot convert ${inputType.toString()} to input type`);
-  }
-  const args = {};
-  Object.entries(input).forEach(([name, field2]) => {
-    tryIn(() => {
-      let fieldName;
-      if (options?.fieldName) {
-        fieldName = `${pascalCase(options.fieldName)}${pascalCase(name)}`;
-      }
-      args[name] = {
-        ...field2,
-        type: ensureInputType(field2, { fieldName })
-      };
-    }, name);
-  });
-  return args;
+	if (input === void 0) return void 0;
+	if (isSilk(input)) {
+		let inputType = getGraphQLType(input);
+		if (isNonNullType(inputType)) inputType = inputType.ofType;
+		if (isObjectType(inputType)) return mapValue(inputType.toConfig().fields, (it, key) => {
+			let fieldName;
+			if (options?.fieldName) fieldName = `${pascalCase(options.fieldName)}${pascalCase(key)}`;
+			return toInputFieldConfig(it, { fieldName });
+		});
+		throw new Error(`Cannot convert ${inputType.toString()} to input type`);
+	}
+	const args = {};
+	Object.entries(input).forEach(([name, field$1]) => {
+		tryIn(() => {
+			let fieldName;
+			if (options?.fieldName) fieldName = `${pascalCase(options.fieldName)}${pascalCase(name)}`;
+			args[name] = {
+				...field$1,
+				type: ensureInputType(field$1, { fieldName })
+			};
+		}, name);
+	});
+	return args;
 }
 function ensureInputType(silkOrType, options) {
-  const gqlType = (() => {
-    if (isSilk(silkOrType)) {
-      return getGraphQLType(silkOrType);
-    }
-    return silkOrType;
-  })();
-  if (isUnionType2(gqlType))
-    throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
-  if (isNonNullType(gqlType)) {
-    return new GraphQLNonNull2(ensureInputType(gqlType.ofType, options));
-  }
-  if (isListType(gqlType)) {
-    return new GraphQLList2(ensureInputType(gqlType.ofType, options));
-  }
-  if (isObjectType2(gqlType) || isInterfaceType(gqlType))
-    return ensureInputObjectType(gqlType, options);
-  return gqlType;
+	const gqlType = (() => {
+		if (isSilk(silkOrType)) return getGraphQLType(silkOrType);
+		return silkOrType;
+	})();
+	if (isUnionType(gqlType)) throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
+	if (isNonNullType(gqlType)) return new GraphQLNonNull(ensureInputType(gqlType.ofType, options));
+	if (isListType(gqlType)) return new GraphQLList(ensureInputType(gqlType.ofType, options));
+	if (isObjectType(gqlType) || isInterfaceType(gqlType)) return ensureInputObjectType(gqlType, options);
+	return gqlType;
 }
 function ensureInputObjectType(object, options) {
-  if (isInputObjectType(object)) return object;
-  const existing = weaverContext.inputMap?.get(object);
-  if (existing != null) return existing;
-  const { astNode, extensionASTNodes, fields, ...config } = object.toConfig();
-  let name = object.name;
-  if (name === LoomObjectType.AUTO_ALIASING) {
-    name = `${pascalCase(options?.fieldName ?? "")}Input`;
-  }
-  const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((n) => n);
-  name = getInputObjectName(name);
-  const input = new GraphQLInputObjectType({
-    ...config,
-    name,
-    fields: provideWeaverContext.inherit(
-      () => mapValue(
-        fields,
-        (it, key) => toInputFieldConfig(it, {
-          fieldName: inputFieldName(name) + pascalCase(key)
-        })
-      )
-    )
-  });
-  weaverContext.inputMap?.set(object, input);
-  return input;
+	if (isInputObjectType(object)) return object;
+	const existing = weaverContext.inputMap?.get(object);
+	if (existing != null) return existing;
+	const { astNode, extensionASTNodes, fields,...config } = object.toConfig();
+	let name = object.name;
+	if (name === LoomObjectType.AUTO_ALIASING) name = `${pascalCase(options?.fieldName ?? "")}Input`;
+	const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((n) => n);
+	name = getInputObjectName(name);
+	const input = new GraphQLInputObjectType({
+		...config,
+		name,
+		fields: provideWeaverContext.inherit(() => mapValue(fields, (it, key) => toInputFieldConfig(it, { fieldName: inputFieldName(name) + pascalCase(key) })))
+	});
+	weaverContext.inputMap?.set(object, input);
+	return input;
 }
-function toInputFieldConfig({ astNode, resolve, ...config }, options) {
-  return { ...config, type: ensureInputType(config.type, options) };
+function toInputFieldConfig({ astNode, resolve,...config }, options) {
+	return {
+		...config,
+		type: ensureInputType(config.type, options)
+	};
 }
 function inputFieldName(name) {
-  while (name.endsWith("Input")) {
-    name = name.slice(0, -"Input".length);
-  }
-  return name;
+	while (name.endsWith("Input")) name = name.slice(0, -5);
+	return name;
 }
 
-// src/schema/object.ts
-var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
-  extraFields = /* @__PURE__ */ new Map();
-  hiddenFields = /* @__PURE__ */ new Set();
-  static AUTO_ALIASING = "__gqloom_auto_aliasing";
-  weaverContext;
-  globalOptions;
-  /**
-   * field name -> resolver
-   */
-  resolvers;
-  constructor(objectOrGetter, options = {}) {
-    const origin = typeof objectOrGetter === "function" ? objectOrGetter() : objectOrGetter;
-    const config = (() => {
-      if (isObjectType3(origin)) {
-        return origin.toConfig();
-      } else if (typeof origin === "string") {
-        return { name: origin, fields: {} };
-      } else {
-        return origin;
-      }
-    })();
-    super(config);
-    this.globalOptions = options.globalOptions;
-    this.weaverContext = options.weaverContext ?? initWeaverContext();
-    this.resolvers = /* @__PURE__ */ new Map();
-    if (this.name !== _LoomObjectType.AUTO_ALIASING) {
-      this.hasExplicitName = true;
-    }
-  }
-  hasExplicitName;
-  _aliases = [];
-  get aliases() {
-    return this._aliases;
-  }
-  addAlias(name) {
-    if (this.hasExplicitName) return;
-    this._aliases.push(name);
-    this.renameByAliases();
-  }
-  renameByAliases() {
-    let name;
-    for (const alias of this.aliases) {
-      if (name === void 0 || alias.length < name.length) {
-        name = alias;
-      }
-    }
-    if (name) this.name = name;
-  }
-  hideField(name) {
-    this.hiddenFields.add(name);
-  }
-  addField(name, field2, resolver2) {
-    const existing = this.extraFields.get(name);
-    if (existing && existing !== field2) {
-      throw new Error(`Field ${name} already exists in ${this.name}`);
-    }
-    this.extraFields.set(name, field2);
-    if (resolver2) this.resolvers.set(name, resolver2);
-  }
-  mergeExtensions(extensions) {
-    this.extensions = deepMerge(this.extensions, extensions);
-  }
-  extraFieldMap;
-  getFields() {
-    const fieldsBySuper = super.getFields();
-    Object.entries(fieldsBySuper).forEach(
-      ([fieldName, field2]) => field2.type = this.getCacheType(field2.type, fieldName)
-    );
-    const extraFields = provideWeaverContext(
-      () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
-      this.weaverContext
-    );
-    if (Object.keys(this.extraFieldMap ?? {}).join() !== Object.keys(extraFields).join()) {
-      this.extraFieldMap = extraFields;
-    }
-    const answer = {
-      ...fieldsBySuper,
-      ...this.extraFieldMap
-    };
-    for (const fieldName of this.hiddenFields) {
-      delete answer[fieldName];
-    }
-    return answer;
-  }
-  mapToFieldConfig(map) {
-    const record = {};
-    for (const [name, field2] of map.entries()) {
-      record[name] = this.toFieldConfig(field2, name);
-    }
-    return record;
-  }
-  toFieldConfig(field2, fieldName) {
-    const outputType = this.getCacheType(
-      getGraphQLType(field2["~meta"].output),
-      fieldName
-    );
-    const resolve = this.provideForResolve(field2, fieldName);
-    const subscribe = this.provideForSubscribe(field2, fieldName);
-    return {
-      ...extract(field2),
-      type: outputType,
-      args: inputToArgs(field2["~meta"].input, {
-        fieldName: fieldName ? parentName(this.name) + fieldName : void 0
-      }),
-      resolve,
-      ...subscribe ? { subscribe } : {}
-    };
-  }
-  provideForResolve(field2, fieldName) {
-    const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
-    switch (field2["~meta"].operation) {
-      case "query":
-      case "mutation": {
-        const operation = field2["~meta"].operation;
-        const middlewares = filterMiddlewares(
-          operation,
-          this.globalOptions?.middlewares,
-          resolverMiddlewares,
-          field2["~meta"].middlewares
-        );
-        return (root, args, context, info) => {
-          const payload = { root, args, context, info, field: field2 };
-          const parseInput = createInputParser(field2["~meta"].input, args);
-          return applyMiddlewares(
-            {
-              operation,
-              outputSilk: field2["~meta"].output,
-              parent: void 0,
-              parseInput,
-              payload
-            },
-            async () => field2["~meta"].resolve(await parseInput.getResult(), payload),
-            middlewares
-          );
-        };
-      }
-      case "field": {
-        const middlewares = filterMiddlewares(
-          "field",
-          this.globalOptions?.middlewares,
-          resolverMiddlewares,
-          field2["~meta"].middlewares
-        );
-        return (root, args, context, info) => {
-          const payload = { root, args, context, info, field: field2 };
-          const parseInput = createInputParser(field2["~meta"].input, args);
-          return applyMiddlewares(
-            {
-              operation: "field",
-              outputSilk: field2["~meta"].output,
-              parent: root,
-              parseInput,
-              payload
-            },
-            async () => field2["~meta"].resolve(
-              root,
-              await parseInput.getResult(),
-              payload
-            ),
-            middlewares
-          );
-        };
-      }
-      case "subscription": {
-        const middlewares = filterMiddlewares(
-          "subscription.resolve",
-          this.globalOptions?.middlewares,
-          resolverMiddlewares,
-          field2["~meta"].middlewares
-        );
-        return (root, args, context, info) => {
-          const payload = { root, args, context, info, field: field2 };
-          const parseInput = createInputParser(field2["~meta"].input, args);
-          return applyMiddlewares(
-            {
-              operation: "subscription.resolve",
-              outputSilk: field2["~meta"].output,
-              parent: root,
-              parseInput,
-              payload
-            },
-            async () => field2["~meta"].resolve(
-              root,
-              await parseInput.getResult(),
-              payload
-            ),
-            middlewares
-          );
-        };
-      }
-    }
-  }
-  provideForSubscribe(field2, fieldName) {
-    if (field2?.["~meta"]?.subscribe == null)
-      return;
-    const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
-    const middlewares = filterMiddlewares(
-      "subscription.subscribe",
-      this.globalOptions?.middlewares,
-      resolverMiddlewares,
-      field2["~meta"].middlewares
-    );
-    return (source, args, context, info) => {
-      const payload = { root: source, args, context, info, field: field2 };
-      const parseInput = createInputParser(field2["~meta"].input, args);
-      return applyMiddlewares(
-        {
-          operation: "subscription.subscribe",
-          outputSilk: field2["~meta"].output,
-          parent: void 0,
-          parseInput,
-          payload
-        },
-        async () => field2["~meta"].subscribe(
-          await parseInput.getResult(),
-          payload
-        ),
-        middlewares
-      );
-    };
-  }
-  getCacheType(gqlType, fieldName) {
-    return getCacheType(gqlType, { ...this.options, fieldName, parent: this });
-  }
-  get options() {
-    const { globalOptions: resolverOptions, weaverContext: weaverContext2 } = this;
-    return { resolverOptions, weaverContext: weaverContext2 };
-  }
+//#endregion
+//#region src/schema/object.ts
+var LoomObjectType = class LoomObjectType extends GraphQLObjectType {
+	extraFields = /* @__PURE__ */ new Map();
+	hiddenFields = /* @__PURE__ */ new Set();
+	static AUTO_ALIASING = "__gqloom_auto_aliasing";
+	weaverContext;
+	globalOptions;
+	/**
+	* field name -> resolver
+	*/
+	resolvers;
+	constructor(objectOrGetter, options = {}) {
+		const origin = typeof objectOrGetter === "function" ? objectOrGetter() : objectOrGetter;
+		const config = (() => {
+			if (isObjectType(origin)) return origin.toConfig();
+			else if (typeof origin === "string") return {
+				name: origin,
+				fields: {}
+			};
+			else return origin;
+		})();
+		super(config);
+		this.globalOptions = options.globalOptions;
+		this.weaverContext = options.weaverContext ?? initWeaverContext();
+		this.resolvers = /* @__PURE__ */ new Map();
+		if (this.name !== LoomObjectType.AUTO_ALIASING) this.hasExplicitName = true;
+	}
+	hasExplicitName;
+	_aliases = [];
+	get aliases() {
+		return this._aliases;
+	}
+	addAlias(name) {
+		if (this.hasExplicitName) return;
+		this._aliases.push(name);
+		this.renameByAliases();
+	}
+	renameByAliases() {
+		let name;
+		for (const alias of this.aliases) if (name === void 0 || alias.length < name.length) name = alias;
+		if (name) this.name = name;
+	}
+	hideField(name) {
+		this.hiddenFields.add(name);
+	}
+	addField(name, field$1, resolver$1) {
+		const existing = this.extraFields.get(name);
+		if (existing && existing !== field$1) throw new Error(`Field ${name} already exists in ${this.name}`);
+		this.extraFields.set(name, field$1);
+		if (resolver$1) this.resolvers.set(name, resolver$1);
+	}
+	mergeExtensions(extensions) {
+		this.extensions = deepMerge(this.extensions, extensions);
+	}
+	extraFieldMap;
+	getFields() {
+		const fieldsBySuper = super.getFields();
+		Object.entries(fieldsBySuper).forEach(([fieldName, field$1]) => field$1.type = this.getCacheType(field$1.type, fieldName));
+		const extraFields = provideWeaverContext(() => defineFieldMap(this.mapToFieldConfig(this.extraFields)), this.weaverContext);
+		if (Object.keys(this.extraFieldMap ?? {}).join() !== Object.keys(extraFields).join()) this.extraFieldMap = extraFields;
+		const answer = {
+			...fieldsBySuper,
+			...this.extraFieldMap
+		};
+		for (const fieldName of this.hiddenFields) delete answer[fieldName];
+		return answer;
+	}
+	mapToFieldConfig(map) {
+		const record = {};
+		for (const [name, field$1] of map.entries()) record[name] = this.toFieldConfig(field$1, name);
+		return record;
+	}
+	toFieldConfig(field$1, fieldName) {
+		const outputType = this.getCacheType(getGraphQLType(field$1["~meta"].output), fieldName);
+		const resolve = this.provideForResolve(field$1, fieldName);
+		const subscribe = this.provideForSubscribe(field$1, fieldName);
+		return {
+			...extract(field$1),
+			type: outputType,
+			args: inputToArgs(field$1["~meta"].input, { fieldName: fieldName ? parentName(this.name) + fieldName : void 0 }),
+			resolve,
+			...subscribe ? { subscribe } : {}
+		};
+	}
+	provideForResolve(field$1, fieldName) {
+		const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
+		switch (field$1["~meta"].operation) {
+			case "query":
+			case "mutation": {
+				const operation = field$1["~meta"].operation;
+				const middlewares = filterMiddlewares(operation, this.globalOptions?.middlewares, resolverMiddlewares, field$1["~meta"].middlewares);
+				return (root, args, context, info) => {
+					const payload = {
+						root,
+						args,
+						context,
+						info,
+						field: field$1
+					};
+					const parseInput = createInputParser(field$1["~meta"].input, args);
+					return applyMiddlewares({
+						operation,
+						outputSilk: field$1["~meta"].output,
+						parent: void 0,
+						parseInput,
+						payload
+					}, async () => field$1["~meta"].resolve(await parseInput.getResult(), payload), middlewares);
+				};
+			}
+			case "field": {
+				const middlewares = filterMiddlewares("field", this.globalOptions?.middlewares, resolverMiddlewares, field$1["~meta"].middlewares);
+				return (root, args, context, info) => {
+					const payload = {
+						root,
+						args,
+						context,
+						info,
+						field: field$1
+					};
+					const parseInput = createInputParser(field$1["~meta"].input, args);
+					return applyMiddlewares({
+						operation: "field",
+						outputSilk: field$1["~meta"].output,
+						parent: root,
+						parseInput,
+						payload
+					}, async () => field$1["~meta"].resolve(root, await parseInput.getResult(), payload), middlewares);
+				};
+			}
+			case "subscription": {
+				const middlewares = filterMiddlewares("subscription.resolve", this.globalOptions?.middlewares, resolverMiddlewares, field$1["~meta"].middlewares);
+				return (root, args, context, info) => {
+					const payload = {
+						root,
+						args,
+						context,
+						info,
+						field: field$1
+					};
+					const parseInput = createInputParser(field$1["~meta"].input, args);
+					return applyMiddlewares({
+						operation: "subscription.resolve",
+						outputSilk: field$1["~meta"].output,
+						parent: root,
+						parseInput,
+						payload
+					}, async () => field$1["~meta"].resolve(root, await parseInput.getResult(), payload), middlewares);
+				};
+			}
+		}
+	}
+	provideForSubscribe(field$1, fieldName) {
+		if (field$1?.["~meta"]?.subscribe == null) return;
+		const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
+		const middlewares = filterMiddlewares("subscription.subscribe", this.globalOptions?.middlewares, resolverMiddlewares, field$1["~meta"].middlewares);
+		return (source, args, context, info) => {
+			const payload = {
+				root: source,
+				args,
+				context,
+				info,
+				field: field$1
+			};
+			const parseInput = createInputParser(field$1["~meta"].input, args);
+			return applyMiddlewares({
+				operation: "subscription.subscribe",
+				outputSilk: field$1["~meta"].output,
+				parent: void 0,
+				parseInput,
+				payload
+			}, async () => field$1["~meta"].subscribe(await parseInput.getResult(), payload), middlewares);
+		};
+	}
+	getCacheType(gqlType, fieldName) {
+		return getCacheType(gqlType, {
+			...this.options,
+			fieldName,
+			parent: this
+		});
+	}
+	get options() {
+		const { globalOptions: resolverOptions, weaverContext: weaverContext$1 } = this;
+		return {
+			resolverOptions,
+			weaverContext: weaverContext$1
+		};
+	}
 };
-function extract(field2) {
-  const { deprecationReason, description, extensions } = field2["~meta"];
-  return {
-    description,
-    deprecationReason,
-    extensions
-  };
+function extract(field$1) {
+	const { deprecationReason, description, extensions } = field$1["~meta"];
+	return {
+		description,
+		deprecationReason,
+		extensions
+	};
 }
 function defineFieldMap(fields) {
-  const fieldMap = resolveObjMapThunk(fields);
-  return mapValue(fieldMap, (fieldConfig, fieldName) => {
-    const argsConfig = fieldConfig.args ?? {};
-    return {
-      name: assertName(fieldName),
-      description: fieldConfig.description,
-      type: fieldConfig.type,
-      args: defineArguments(argsConfig),
-      resolve: fieldConfig.resolve,
-      subscribe: fieldConfig.subscribe,
-      deprecationReason: fieldConfig.deprecationReason,
-      extensions: toObjMap(fieldConfig.extensions),
-      astNode: fieldConfig.astNode
-    };
-  });
+	const fieldMap = resolveObjMapThunk(fields);
+	return mapValue(fieldMap, (fieldConfig, fieldName) => {
+		const argsConfig = fieldConfig.args ?? {};
+		return {
+			name: assertName(fieldName),
+			description: fieldConfig.description,
+			type: fieldConfig.type,
+			args: defineArguments(argsConfig),
+			resolve: fieldConfig.resolve,
+			subscribe: fieldConfig.subscribe,
+			deprecationReason: fieldConfig.deprecationReason,
+			extensions: toObjMap(fieldConfig.extensions),
+			astNode: fieldConfig.astNode
+		};
+	});
 }
 function defineArguments(args) {
-  return Object.entries(args).map(([argName, argConfig]) => ({
-    name: assertName(argName),
-    description: argConfig.description,
-    type: argConfig.type,
-    defaultValue: argConfig.defaultValue,
-    deprecationReason: argConfig.deprecationReason,
-    extensions: toObjMap(argConfig.extensions),
-    astNode: argConfig.astNode
-  }));
+	return Object.entries(args).map(([argName, argConfig]) => ({
+		name: assertName(argName),
+		description: argConfig.description,
+		type: argConfig.type,
+		defaultValue: argConfig.defaultValue,
+		deprecationReason: argConfig.deprecationReason,
+		extensions: toObjMap(argConfig.extensions),
+		astNode: argConfig.astNode
+	}));
 }
-var OPERATION_OBJECT_NAMES = /* @__PURE__ */ new Set([
-  "Query",
-  "Mutation",
-  "Subscription"
+const OPERATION_OBJECT_NAMES = new Set([
+	"Query",
+	"Mutation",
+	"Subscription"
 ]);
 function getCacheType(gqlType, options = {}) {
-  const context = options.weaverContext ?? weaverContext;
-  if (gqlType instanceof LoomObjectType) return gqlType;
-  if (isObjectType3(gqlType)) {
-    const gqlObject = context.loomObjectMap?.get(gqlType);
-    if (gqlObject != null) return gqlObject;
-    const loomObject = new LoomObjectType(gqlType, options);
-    context.loomObjectMap?.set(gqlType, loomObject);
-    if (options.fieldName && options.parent) {
-      loomObject.addAlias(
-        parentName(options.parent.name) + pascalCase(options.fieldName)
-      );
-    }
-    return loomObject;
-  } else if (isListType2(gqlType)) {
-    return new GraphQLList3(getCacheType(gqlType.ofType, options));
-  } else if (isNonNullType2(gqlType)) {
-    return new GraphQLNonNull3(getCacheType(gqlType.ofType, options));
-  } else if (isUnionType3(gqlType)) {
-    const existing = context.loomUnionMap?.get(gqlType);
-    if (existing != null) return existing;
-    const config = gqlType.toConfig();
-    const unionType = new GraphQLUnionType({
-      ...config,
-      types: config.types.map(
-        (type) => getCacheType(type, options)
-      )
-    });
-    context.loomUnionMap?.set(gqlType, unionType);
-    return unionType;
-  }
-  return gqlType;
+	const context = options.weaverContext ?? weaverContext;
+	if (gqlType instanceof LoomObjectType) return gqlType;
+	if (isObjectType(gqlType)) {
+		const gqlObject = context.loomObjectMap?.get(gqlType);
+		if (gqlObject != null) return gqlObject;
+		const loomObject = new LoomObjectType(gqlType, options);
+		context.loomObjectMap?.set(gqlType, loomObject);
+		if (options.fieldName && options.parent) loomObject.addAlias(parentName(options.parent.name) + pascalCase(options.fieldName));
+		return loomObject;
+	} else if (isListType(gqlType)) return new GraphQLList(getCacheType(gqlType.ofType, options));
+	else if (isNonNullType(gqlType)) return new GraphQLNonNull(getCacheType(gqlType.ofType, options));
+	else if (isUnionType(gqlType)) {
+		const existing = context.loomUnionMap?.get(gqlType);
+		if (existing != null) return existing;
+		const config = gqlType.toConfig();
+		const unionType = new GraphQLUnionType({
+			...config,
+			types: config.types.map((type) => getCacheType(type, options))
+		});
+		context.loomUnionMap?.set(gqlType, unionType);
+		return unionType;
+	}
+	return gqlType;
 }
 function parentName(name) {
-  if (OPERATION_OBJECT_NAMES.has(name)) name = "";
-  return name;
+	if (OPERATION_OBJECT_NAMES.has(name)) name = "";
+	return name;
 }
 
-// src/schema/schema-weaver.ts
+//#endregion
+//#region src/schema/schema-weaver.ts
 function isSchemaVendorWeaver(some) {
-  if (some == null) return false;
-  if (typeof some !== "object" && typeof some !== "function") return false;
-  if (!("getGraphQLType" in some) || typeof some.getGraphQLType !== "function")
-    return false;
-  if (!("vendor" in some) || typeof some.vendor !== "string") return false;
-  return true;
+	if (some == null) return false;
+	if (typeof some !== "object" && typeof some !== "function") return false;
+	if (!("getGraphQLType" in some) || typeof some.getGraphQLType !== "function") return false;
+	if (!("vendor" in some) || typeof some.vendor !== "string") return false;
+	return true;
 }
 
-// src/schema/schema-loom.ts
-import {
-  GraphQLSchema,
-  isEnumType as isEnumType2,
-  isNonNullType as isNonNullType3,
-  isObjectType as isObjectType4,
-  isUnionType as isUnionType4
-} from "graphql";
-var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
-  query;
-  mutation;
-  subscription;
-  types;
-  context;
-  resolverOptions;
-  /**
-   * Create a Schema Weaver config object
-   * @param config Schema Weaver config options
-   * @returns a Schema Weaver config object
-   */
-  static config(config) {
-    return {
-      ...config,
-      [WEAVER_CONFIG]: "gqloom.core.schema"
-    };
-  }
-  constructor({ query: query2, mutation: mutation2, subscription: subscription2, types } = {}, context) {
-    if (query2 != null) this.query = query2;
-    if (mutation2 != null) this.mutation = mutation2;
-    if (subscription2 != null) this.subscription = subscription2;
-    this.types = new Set(types ?? []);
-    this.context = context ?? initWeaverContext();
-  }
-  use(...middlewares) {
-    this.resolverOptions ??= {};
-    this.resolverOptions.middlewares ??= [];
-    this.resolverOptions.middlewares.push(...middlewares);
-    return this;
-  }
-  add(resolver2, modifyParent) {
-    provideWeaverContext(
-      () => this.addResolver(resolver2, modifyParent),
-      this.context
-    );
-    return this;
-  }
-  addVendor(weaver) {
-    this.context.vendorWeavers.set(weaver.vendor, weaver);
-    return this;
-  }
-  addType(silk2) {
-    const gqlType = provideWeaverContext(() => {
-      let gqlType2 = getGraphQLType(silk2);
-      if (isNonNullType3(gqlType2)) gqlType2 = gqlType2.ofType;
-      if (isObjectType4(gqlType2)) {
-        const existing = this.context.loomObjectMap.get(gqlType2);
-        if (existing != null) return existing;
-        const extraObject = new LoomObjectType(gqlType2, this.fieldOptions);
-        this.context.loomObjectMap.set(gqlType2, extraObject);
-        return extraObject;
-      } else if (isUnionType4(gqlType2) || isEnumType2(gqlType2)) {
-        return gqlType2;
-      }
-      throw new Error(
-        `${gqlType2?.name ?? gqlType2.toString()} is not a named type`
-      );
-    }, this.context);
-    this.types.add(gqlType);
-    return this;
-  }
-  setConfig(config) {
-    this.context.setConfig(config);
-    return this;
-  }
-  weaveGraphQLSchema() {
-    const { query: query2, mutation: mutation2, subscription: subscription2, types } = this;
-    const config = this.context.getConfig("gqloom.core.schema");
-    const schema = new GraphQLSchema({
-      query: query2,
-      mutation: mutation2,
-      subscription: subscription2,
-      types: [...types ?? [], ...config?.types ?? []],
-      ...config
-    });
-    return schema;
-  }
-  addResolver(resolver2, modifyParent) {
-    const resolverOptions = resolver2["~meta"].options;
-    const parent = resolver2["~meta"].parent;
-    let parentObject = (() => {
-      if (parent == null) return void 0;
-      let gqlType = getGraphQLType(parent);
-      if (isNonNullType3(gqlType)) gqlType = gqlType.ofType;
-      if (!isObjectType4(gqlType)) {
-        throw new Error(
-          `${gqlType?.name ?? gqlType.toString()} is not an object type`
-        );
-      }
-      const existing = this.context.loomObjectMap.get(gqlType);
-      if (existing != null) return existing;
-      const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
-      this.context.loomObjectMap.set(gqlType, extraObject);
-      this.types.add(extraObject);
-      return extraObject;
-    })();
-    if (resolverOptions?.extensions && parentObject)
-      parentObject.mergeExtensions(resolverOptions.extensions);
-    if (modifyParent != null && parentObject)
-      parentObject = modifyParent(parentObject);
-    Object.entries(resolver2["~meta"].fields).forEach(([name, field2]) => {
-      if (field2 === FIELD_HIDDEN) {
-        if (parentObject == null) return;
-        parentObject.hideField(name);
-      } else if (field2["~meta"].operation === "field") {
-        if (parentObject == null) return;
-        parentObject.addField(name, field2, resolver2);
-      } else {
-        const operationObject = this.getOperationObject(
-          field2["~meta"].operation
-        );
-        operationObject.addField(name, field2, resolver2);
-      }
-    });
-    return this;
-  }
-  getOperationObject(type) {
-    switch (type) {
-      case "query": {
-        this.query ??= new LoomObjectType(
-          { name: "Query", fields: {} },
-          this.fieldOptions
-        );
-        return this.query;
-      }
-      case "mutation": {
-        this.mutation ??= new LoomObjectType(
-          { name: "Mutation", fields: {} },
-          this.fieldOptions
-        );
-        return this.mutation;
-      }
-      case "subscription": {
-        this.subscription ??= new LoomObjectType(
-          { name: "Subscription", fields: {} },
-          this.fieldOptions
-        );
-        return this.subscription;
-      }
-    }
-  }
-  get fieldOptions() {
-    const { resolverOptions, context } = this;
-    return { globalOptions: resolverOptions, weaverContext: context };
-  }
-  static optionsFrom(...inputs) {
-    const configs = /* @__PURE__ */ new Set();
-    const middlewares = /* @__PURE__ */ new Set();
-    const resolvers = /* @__PURE__ */ new Set();
-    const silks = /* @__PURE__ */ new Set();
-    const weavers = /* @__PURE__ */ new Set();
-    let context;
-    for (const item of inputs) {
-      if (item == null) continue;
-      if (isSchemaVendorWeaver(item)) {
-        weavers.add(item);
-      } else if (typeof item === "function") {
-        middlewares.add(item);
-      } else if (WEAVER_CONFIG in item) {
-        configs.add(item);
-        if (item.vendorWeaver) weavers.add(item.vendorWeaver);
-        if (item[WEAVER_CONFIG] === "gqloom.core.schema") {
-          context = item.weaverContext;
-        }
-      } else if (isSilk(item)) {
-        silks.add(item);
-      } else if (item["~meta"][IS_RESOLVER]) {
-        resolvers.add(item);
-      }
-    }
-    return { context, configs, middlewares, resolvers, silks, weavers };
-  }
-  /**
-   * Weave a GraphQL Schema from resolvers
-   * @param inputs Resolvers, Global Middlewares, WeaverConfigs Or SchemaWeaver
-   * @returns GraphQL Schema
-   */
-  static weave(...inputs) {
-    const { context, configs, middlewares, resolvers, silks, weavers } = _GraphQLSchemaLoom.optionsFrom(...inputs);
-    const weaver = new _GraphQLSchemaLoom({}, context);
-    configs.forEach((it) => weaver.setConfig(it));
-    weavers.forEach((it) => weaver.addVendor(it));
-    middlewares.forEach((it) => weaver.use(it));
-    resolvers.forEach((it) => weaver.add(it));
-    silks.forEach((it) => weaver.addType(it));
-    return weaver.weaveGraphQLSchema();
-  }
+//#endregion
+//#region src/schema/schema-loom.ts
+var GraphQLSchemaLoom = class GraphQLSchemaLoom {
+	query;
+	mutation;
+	subscription;
+	types;
+	context;
+	resolverOptions;
+	/**
+	* Create a Schema Weaver config object
+	* @param config Schema Weaver config options
+	* @returns a Schema Weaver config object
+	*/
+	static config(config) {
+		return {
+			...config,
+			[WEAVER_CONFIG]: "gqloom.core.schema"
+		};
+	}
+	constructor({ query: query$1, mutation: mutation$1, subscription: subscription$1, types } = {}, context) {
+		if (query$1 != null) this.query = query$1;
+		if (mutation$1 != null) this.mutation = mutation$1;
+		if (subscription$1 != null) this.subscription = subscription$1;
+		this.types = new Set(types ?? []);
+		this.context = context ?? initWeaverContext();
+	}
+	use(...middlewares) {
+		this.resolverOptions ??= {};
+		this.resolverOptions.middlewares ??= [];
+		this.resolverOptions.middlewares.push(...middlewares);
+		return this;
+	}
+	add(resolver$1, modifyParent) {
+		provideWeaverContext(() => this.addResolver(resolver$1, modifyParent), this.context);
+		return this;
+	}
+	addVendor(weaver) {
+		this.context.vendorWeavers.set(weaver.vendor, weaver);
+		return this;
+	}
+	addType(silk$1) {
+		const gqlType = provideWeaverContext(() => {
+			let gqlType$1 = getGraphQLType(silk$1);
+			if (isNonNullType(gqlType$1)) gqlType$1 = gqlType$1.ofType;
+			if (isObjectType(gqlType$1)) {
+				const existing = this.context.loomObjectMap.get(gqlType$1);
+				if (existing != null) return existing;
+				const extraObject = new LoomObjectType(gqlType$1, this.fieldOptions);
+				this.context.loomObjectMap.set(gqlType$1, extraObject);
+				return extraObject;
+			} else if (isUnionType(gqlType$1) || isEnumType(gqlType$1)) return gqlType$1;
+			throw new Error(`${gqlType$1?.name ?? gqlType$1.toString()} is not a named type`);
+		}, this.context);
+		this.types.add(gqlType);
+		return this;
+	}
+	setConfig(config) {
+		this.context.setConfig(config);
+		return this;
+	}
+	weaveGraphQLSchema() {
+		const { query: query$1, mutation: mutation$1, subscription: subscription$1, types } = this;
+		const config = this.context.getConfig("gqloom.core.schema");
+		const schema = new GraphQLSchema({
+			query: query$1,
+			mutation: mutation$1,
+			subscription: subscription$1,
+			types: [...types ?? [], ...config?.types ?? []],
+			...config
+		});
+		return schema;
+	}
+	addResolver(resolver$1, modifyParent) {
+		const resolverOptions = resolver$1["~meta"].options;
+		const parent = resolver$1["~meta"].parent;
+		let parentObject = (() => {
+			if (parent == null) return void 0;
+			let gqlType = getGraphQLType(parent);
+			if (isNonNullType(gqlType)) gqlType = gqlType.ofType;
+			if (!isObjectType(gqlType)) throw new Error(`${gqlType?.name ?? gqlType.toString()} is not an object type`);
+			const existing = this.context.loomObjectMap.get(gqlType);
+			if (existing != null) return existing;
+			const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
+			this.context.loomObjectMap.set(gqlType, extraObject);
+			this.types.add(extraObject);
+			return extraObject;
+		})();
+		if (resolverOptions?.extensions && parentObject) parentObject.mergeExtensions(resolverOptions.extensions);
+		if (modifyParent != null && parentObject) parentObject = modifyParent(parentObject);
+		Object.entries(resolver$1["~meta"].fields).forEach(([name, field$1]) => {
+			if (field$1 === FIELD_HIDDEN) {
+				if (parentObject == null) return;
+				parentObject.hideField(name);
+			} else if (field$1["~meta"].operation === "field") {
+				if (parentObject == null) return;
+				parentObject.addField(name, field$1, resolver$1);
+			} else {
+				const operationObject = this.getOperationObject(field$1["~meta"].operation);
+				operationObject.addField(name, field$1, resolver$1);
+			}
+		});
+		return this;
+	}
+	getOperationObject(type) {
+		switch (type) {
+			case "query":
+				this.query ??= new LoomObjectType({
+					name: "Query",
+					fields: {}
+				}, this.fieldOptions);
+				return this.query;
+			case "mutation":
+				this.mutation ??= new LoomObjectType({
+					name: "Mutation",
+					fields: {}
+				}, this.fieldOptions);
+				return this.mutation;
+			case "subscription":
+				this.subscription ??= new LoomObjectType({
+					name: "Subscription",
+					fields: {}
+				}, this.fieldOptions);
+				return this.subscription;
+		}
+	}
+	get fieldOptions() {
+		const { resolverOptions, context } = this;
+		return {
+			globalOptions: resolverOptions,
+			weaverContext: context
+		};
+	}
+	static optionsFrom(...inputs) {
+		const configs = /* @__PURE__ */ new Set();
+		const middlewares = /* @__PURE__ */ new Set();
+		const resolvers = /* @__PURE__ */ new Set();
+		const silks = /* @__PURE__ */ new Set();
+		const weavers = /* @__PURE__ */ new Set();
+		let context;
+		for (const item of inputs) {
+			if (item == null) continue;
+			if (isSchemaVendorWeaver(item)) weavers.add(item);
+			else if (typeof item === "function") middlewares.add(item);
+			else if (WEAVER_CONFIG in item) {
+				configs.add(item);
+				if (item.vendorWeaver) weavers.add(item.vendorWeaver);
+				if (item[WEAVER_CONFIG] === "gqloom.core.schema") context = item.weaverContext;
+			} else if (isSilk(item)) silks.add(item);
+			else if (item["~meta"][IS_RESOLVER]) resolvers.add(item);
+		}
+		return {
+			context,
+			configs,
+			middlewares,
+			resolvers,
+			silks,
+			weavers
+		};
+	}
+	/**
+	* Weave a GraphQL Schema from resolvers
+	* @param inputs Resolvers, Global Middlewares, WeaverConfigs Or SchemaWeaver
+	* @returns GraphQL Schema
+	*/
+	static weave(...inputs) {
+		const { context, configs, middlewares, resolvers, silks, weavers } = GraphQLSchemaLoom.optionsFrom(...inputs);
+		const weaver = new GraphQLSchemaLoom({}, context);
+		configs.forEach((it) => weaver.setConfig(it));
+		weavers.forEach((it) => weaver.addVendor(it));
+		middlewares.forEach((it) => weaver.use(it));
+		resolvers.forEach((it) => weaver.add(it));
+		silks.forEach((it) => weaver.addType(it));
+		return weaver.weaveGraphQLSchema();
+	}
 };
-var weave = GraphQLSchemaLoom.weave;
+/**
+* Weave a GraphQL Schema from resolvers
+* @param inputs Resolvers, Global Middlewares or WeaverConfigs
+* @returns GraphQL Schema
+*/
+const weave = GraphQLSchemaLoom.weave;
 
-// src/schema/interface.ts
-import {
-  GraphQLInterfaceType,
-  isInterfaceType as isInterfaceType2,
-  isObjectType as isObjectType5
-} from "graphql";
+//#endregion
+//#region src/schema/interface.ts
 function ensureInterfaceType(gqlType, interfaceConfig) {
-  if (isInterfaceType2(gqlType)) return gqlType;
-  if (!isObjectType5(gqlType))
-    throw new Error(`${gqlType.toString()} is not an object`);
-  const key = gqlType;
-  const existing = weaverContext.interfaceMap?.get(key);
-  if (existing != null) return existing;
-  const {
-    astNode: _,
-    extensionASTNodes: _1,
-    fields,
-    ...config
-  } = gqlType.toConfig();
-  const interfaceType = new GraphQLInterfaceType({
-    ...config,
-    ...interfaceConfig,
-    fields: mapValue(fields, (field2) => {
-      return { ...field2, type: getCacheType(field2.type) };
-    })
-  });
-  weaverContext.interfaceMap?.set(key, interfaceType);
-  return interfaceType;
+	if (isInterfaceType(gqlType)) return gqlType;
+	if (!isObjectType(gqlType)) throw new Error(`${gqlType.toString()} is not an object`);
+	const key = gqlType;
+	const existing = weaverContext.interfaceMap?.get(key);
+	if (existing != null) return existing;
+	const { astNode: _, extensionASTNodes: _1, fields,...config } = gqlType.toConfig();
+	const interfaceType = new GraphQLInterfaceType({
+		...config,
+		...interfaceConfig,
+		fields: mapValue(fields, (field$1) => {
+			return {
+				...field$1,
+				type: getCacheType(field$1.type)
+			};
+		})
+	});
+	weaverContext.interfaceMap?.set(key, interfaceType);
+	return interfaceType;
 }
-export {
-  BaseChainFactory,
-  ChainResolver,
-  EasyDataLoader,
-  FieldChainFactory,
-  FieldFactoryWithResolve,
-  GraphQLSchemaLoom,
-  LoomDataLoader,
-  LoomObjectType,
-  MutationChainFactory,
-  MutationFactoryWithResolve,
-  OPERATION_OBJECT_NAMES,
-  ObjectChainResolver,
-  QueryChainFactory,
-  QueryFactoryWithResolve,
-  symbols_exports as SYMBOLS,
-  SubscriptionChainFactory,
-  applyMiddlewares,
-  assignContextMap,
-  capitalize,
-  collectName,
-  collectNames,
-  createField,
-  createInputParser,
-  createMutation,
-  createQuery,
-  createSubscription,
-  deepMerge,
-  defaultSubscriptionResolve,
-  ensureInputObjectType,
-  ensureInputType,
-  ensureInterfaceType,
-  field,
-  filterMiddlewares,
-  getCacheType,
-  getFieldOptions,
-  getGraphQLType,
-  getMemoizationMap,
-  getOperationOptions,
-  getResolvingFields,
-  getStandardValue,
-  getSubscriptionOptions,
-  initWeaverContext,
-  inputToArgs,
-  isOnlyMemoryPayload,
-  isSchemaVendorWeaver,
-  isSilk,
-  listSilk,
-  loom,
-  mapValue,
-  markErrorLocation,
-  markLocation,
-  meta,
-  mutation,
-  nonNullSilk,
-  notNullish,
-  nullableSilk,
-  onlyMemoization,
-  parseInputValue,
-  parseResolvingFields,
-  parseSilk,
-  pascalCase,
-  provideWeaverContext,
-  query,
-  resolver,
-  screamingSnakeCase,
-  silk,
-  subscription,
-  toObjMap,
-  tryIn,
-  weave,
-  weaverContext
-};
+
+//#endregion
+export { BaseChainFactory, ChainResolver, EasyDataLoader, FieldChainFactory, FieldFactoryWithResolve, GraphQLSchemaLoom, LoomDataLoader, LoomObjectType, MutationChainFactory, MutationFactoryWithResolve, OPERATION_OBJECT_NAMES, ObjectChainResolver, QueryChainFactory, QueryFactoryWithResolve, symbols_exports as SYMBOLS, SubscriptionChainFactory, applyMiddlewares, assignContextMap, capitalize, collectName, collectNames, createField, createInputParser, createMutation, createQuery, createSubscription, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, filterMiddlewares, getCacheType, getDeepResolvingFields, getFieldOptions, getGraphQLType, getMemoizationMap, getOperationOptions, getResolvingFields, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, meta, mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseResolvingFields, parseSilk, pascalCase, provideWeaverContext, query, resolver, screamingSnakeCase, silk, subscription, toObjMap, tryIn, weave, weaverContext };