@gqloom/core 0.10.1 → 0.11.0

package/dist/index.cjs

@@ -1,2155 +1,1830 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BaseChainFactory: () => BaseChainFactory,
-  ChainResolver: () => ChainResolver,
-  EasyDataLoader: () => EasyDataLoader,
-  FieldChainFactory: () => FieldChainFactory,
-  FieldFactoryWithResolve: () => FieldFactoryWithResolve,
-  GraphQLSchemaLoom: () => GraphQLSchemaLoom,
-  LoomDataLoader: () => LoomDataLoader,
-  LoomObjectType: () => LoomObjectType,
-  MutationChainFactory: () => MutationChainFactory,
-  MutationFactoryWithResolve: () => MutationFactoryWithResolve,
-  OPERATION_OBJECT_NAMES: () => OPERATION_OBJECT_NAMES,
-  ObjectChainResolver: () => ObjectChainResolver,
-  QueryChainFactory: () => QueryChainFactory,
-  QueryFactoryWithResolve: () => QueryFactoryWithResolve,
-  SYMBOLS: () => symbols_exports,
-  SubscriptionChainFactory: () => SubscriptionChainFactory,
-  applyMiddlewares: () => applyMiddlewares,
-  assignContextMap: () => assignContextMap,
-  capitalize: () => capitalize,
-  collectName: () => collectName,
-  collectNames: () => collectNames,
-  createField: () => createField,
-  createInputParser: () => createInputParser,
-  createMutation: () => createMutation,
-  createQuery: () => createQuery,
-  createSubscription: () => createSubscription,
-  deepMerge: () => deepMerge,
-  defaultSubscriptionResolve: () => defaultSubscriptionResolve,
-  ensureInputObjectType: () => ensureInputObjectType,
-  ensureInputType: () => ensureInputType,
-  ensureInterfaceType: () => ensureInterfaceType,
-  field: () => field,
-  filterMiddlewares: () => filterMiddlewares,
-  getCacheType: () => getCacheType,
-  getFieldOptions: () => getFieldOptions,
-  getGraphQLType: () => getGraphQLType,
-  getMemoizationMap: () => getMemoizationMap,
-  getOperationOptions: () => getOperationOptions,
-  getResolvingFields: () => getResolvingFields,
-  getStandardValue: () => getStandardValue,
-  getSubscriptionOptions: () => getSubscriptionOptions,
-  initWeaverContext: () => initWeaverContext,
-  inputToArgs: () => inputToArgs,
-  isOnlyMemoryPayload: () => isOnlyMemoryPayload,
-  isSchemaVendorWeaver: () => isSchemaVendorWeaver,
-  isSilk: () => isSilk,
-  listSilk: () => listSilk,
-  loom: () => loom,
-  mapValue: () => mapValue,
-  markErrorLocation: () => markErrorLocation,
-  markLocation: () => markLocation,
-  meta: () => meta,
-  mutation: () => mutation,
-  nonNullSilk: () => nonNullSilk,
-  notNullish: () => notNullish,
-  nullableSilk: () => nullableSilk,
-  onlyMemoization: () => onlyMemoization,
-  parseInputValue: () => parseInputValue,
-  parseResolvingFields: () => parseResolvingFields,
-  parseSilk: () => parseSilk,
-  pascalCase: () => pascalCase,
-  provideWeaverContext: () => provideWeaverContext,
-  query: () => query,
-  resolver: () => resolver,
-  screamingSnakeCase: () => screamingSnakeCase,
-  silk: () => silk,
-  subscription: () => subscription,
-  toObjMap: () => toObjMap,
-  tryIn: () => tryIn,
-  weave: () => weave,
-  weaverContext: () => weaverContext
-});
-module.exports = __toCommonJS(src_exports);
+const require_context = require('./context-3UlS1xGQ.cjs');
+let graphql = require("graphql");
+graphql = require_context.__toESM(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 };
-}
-
-// src/utils/parse-resolving-fields.ts
-var import_graphql3 = require("graphql");
-
-// src/utils/constants.ts
-var DERIVED_DEPENDENCIES = "loom.derived-from-dependencies";
-
-// src/utils/type.ts
-var import_graphql = require("graphql");
-var import_graphql2 = require("graphql");
-function unwrapType(gqlType) {
-  if ((0, import_graphql2.isNonNullType)(gqlType)) {
-    return unwrapType(gqlType.ofType);
-  }
-  if ((0, import_graphql.isListType)(gqlType)) {
-    return unwrapType(gqlType.ofType);
-  }
-  return gqlType;
+	return { "~meta": data };
 }
 
-// src/utils/parse-resolving-fields.ts
-function getResolvingFields(payload) {
-  const requestedFields = parseResolvingFields(payload.info);
-  const derivedFields = /* @__PURE__ */ new Set();
-  const derivedDependencies = /* @__PURE__ */ new Set();
-  const resolvingObject = unwrapType(payload.info.returnType);
-  if ((0, import_graphql3.isObjectType)(resolvingObject)) {
-    const objectFields = resolvingObject.getFields();
-    for (const requestedFieldName of requestedFields) {
-      const field2 = objectFields[requestedFieldName];
-      if (field2) {
-        const deps = field2.extensions?.[DERIVED_DEPENDENCIES];
-        if (deps && Array.isArray(deps) && deps.length > 0) {
-          derivedFields.add(requestedFieldName);
-          for (const d of deps) derivedDependencies.add(d);
-        }
-      }
-    }
-  }
-  const selectedFields = new Set(requestedFields);
-  for (const f of derivedFields) selectedFields.delete(f);
-  for (const d of derivedDependencies) selectedFields.add(d);
-  return { requestedFields, derivedFields, derivedDependencies, selectedFields };
-}
-function parseResolvingFields(info, maxDepth = 1) {
-  return new ResolvingFieldsParser(info, maxDepth).parse();
-}
-var ResolvingFieldsParser = class {
-  /** Store unique field paths */
-  fields = /* @__PURE__ */ new Set();
-  /** Track visited fragments to prevent circular references */
-  visitedFragments = /* @__PURE__ */ new Set();
-  /** The GraphQL resolve info object */
-  info;
-  /** Maximum depth of nested fields to parse */
-  maxDepth;
-  constructor(info, maxDepth) {
-    this.info = info;
-    this.maxDepth = maxDepth;
-  }
-  /**
-   * Parses the GraphQL resolve info to extract all requested fields.
-   * @returns A Set of field paths
-   */
-  parse() {
-    for (const fieldNode of this.info.fieldNodes) {
-      this.collectFields(fieldNode.selectionSet);
-    }
-    return this.fields;
-  }
-  /**
-   * Recursively collects fields from a selection set.
-   * Handles fields, inline fragments, and fragment spreads.
-   *
-   * @param selectionSet - The selection set to process
-   * @param parentPath - The path of the parent field (for nested fields)
-   * @param currentDepth - Current depth of recursion
-   */
-  collectFields(selectionSet, parentPath = "", currentDepth = 0) {
-    if (!selectionSet?.selections.length || currentDepth >= this.maxDepth)
-      return;
-    for (const selection of selectionSet.selections) {
-      if (!this.shouldIncludeNode(selection)) continue;
-      switch (selection.kind) {
-        case import_graphql3.Kind.FIELD: {
-          const fieldName = selection.name.value;
-          const fieldPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
-          this.fields.add(fieldPath);
-          const hasSelectionSet = selection.selectionSet != null;
-          if (hasSelectionSet) {
-            this.collectFields(
-              selection.selectionSet,
-              fieldPath,
-              currentDepth + 1
-            );
-          }
-          break;
-        }
-        case import_graphql3.Kind.INLINE_FRAGMENT: {
-          if (selection.selectionSet) {
-            this.collectFields(selection.selectionSet, parentPath, currentDepth);
-          }
-          break;
-        }
-        case import_graphql3.Kind.FRAGMENT_SPREAD: {
-          const fragmentName = selection.name.value;
-          if (this.visitedFragments.has(fragmentName)) continue;
-          this.visitedFragments.add(fragmentName);
-          const fragment = this.info.fragments[fragmentName];
-          if (fragment) {
-            this.collectFields(fragment.selectionSet, parentPath, currentDepth);
-          }
-          break;
-        }
-      }
-    }
-  }
-  /**
-   * Extracts the boolean value from a directive's 'if' argument.
-   * Handles both literal boolean values and variables.
-   *
-   * @param directive - The directive node to extract value from
-   * @returns The boolean value of the directive's condition
-   */
-  getDirectiveValue(directive) {
-    const ifArg = directive.arguments?.find(
-      (arg) => arg.name.value === "if"
-    );
-    if (!ifArg) return true;
-    const value = ifArg.value;
-    if (value.kind === import_graphql3.Kind.BOOLEAN) {
-      return value.value;
-    }
-    if (value.kind === import_graphql3.Kind.VARIABLE) {
-      const variableName = value.name.value;
-      const variableValue = this.info.variableValues?.[variableName];
-      return variableValue === true;
-    }
-    return true;
-  }
-  /**
-   * Determines if a selection node should be included based on its directives.
-   * Handles both @include and @skip directives.
-   *
-   * @param node - The selection node to check
-   * @returns Whether the node should be included
-   */
-  shouldIncludeNode(node) {
-    if (!node.directives?.length) return true;
-    return node.directives.every((directive) => {
-      const isIncludeDirective = directive.name.value === "include";
-      if (isIncludeDirective) {
-        return this.getDirectiveValue(directive);
-      }
-      if (directive.name.value === "skip") {
-        return !this.getDirectiveValue(directive);
-      }
-      return true;
-    });
-  }
-};
-
-// 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/utils/symbols.ts
-var symbols_exports = {};
-__export(symbols_exports, {
-  CONTEXT_MAP_KEY: () => CONTEXT_MAP_KEY,
-  FIELD_HIDDEN: () => FIELD_HIDDEN,
-  GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
-  IS_RESOLVER: () => IS_RESOLVER,
-  RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
-  WEAVER_CONFIG: () => WEAVER_CONFIG
-});
-var GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
-var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
-var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
-var IS_RESOLVER = Symbol.for("gqloom.is-resolver");
-var CONTEXT_MAP_KEY = Symbol.for("gqloom.context-map");
-var FIELD_HIDDEN = false;
-
-// src/utils/context.ts
-function onlyMemoization() {
-  return { memoization: /* @__PURE__ */ new WeakMap(), isMemoization: true };
-}
-function isOnlyMemoryPayload(payload) {
-  return payload.isMemoization === true;
-}
-function getMemoizationMap(payload) {
-  if (isOnlyMemoryPayload(payload)) return payload.memoization;
-  if (typeof payload.context === "undefined") {
-    Object.defineProperty(payload, "context", { value: {} });
-  }
-  return assignContextMap(payload.context);
-}
-function assignContextMap(target) {
-  target[CONTEXT_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
-  return target[CONTEXT_MAP_KEY];
-}
-
-// src/resolver/silk.ts
-var import_graphql5 = require("graphql");
-
-// src/schema/weaver-context.ts
-var import_graphql4 = require("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 ((0, import_graphql4.isObjectType)(gqlType) || (0, import_graphql4.isUnionType)(gqlType) || (0, import_graphql4.isEnumType)(gqlType) || (0, import_graphql4.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[require_context.WEAVER_CONFIG];
+			this.configs.set(key, config);
+		},
+		deleteConfig(key) {
+			this.configs.delete(key);
+		},
+		names,
+		namedTypes: /* @__PURE__ */ new Map(),
+		memoNamedType(gqlTypeValue) {
+			const gqlType = gqlTypeValue;
+			if ((0, graphql.isObjectType)(gqlType) || (0, graphql.isUnionType)(gqlType) || (0, graphql.isEnumType)(gqlType) || (0, graphql.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[require_context.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 {
+		[require_context.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 import_graphql5.GraphQLNonNull) {
-        return originType;
-      } else {
-        return new import_graphql5.GraphQLNonNull(originType);
-      }
-    }
-  };
+	return {
+		...origin,
+		[require_context.GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof graphql.GraphQLNonNull) return originType;
+			else return new graphql.GraphQLNonNull(originType);
+		}
+	};
 }
+/**
+* List Silk.
+*/
 function listSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      let originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql5.GraphQLNonNull && originType.ofType instanceof import_graphql5.GraphQLList) {
-        originType = originType.ofType.ofType;
-      }
-      if (originType instanceof import_graphql5.GraphQLList) {
-        originType = originType.ofType;
-      }
-      return new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(originType));
-    }
-  };
+	return {
+		...origin,
+		[require_context.GET_GRAPHQL_TYPE]: () => {
+			let originType = getGraphQLType(origin);
+			if (originType instanceof graphql.GraphQLNonNull && originType.ofType instanceof graphql.GraphQLList) originType = originType.ofType.ofType;
+			if (originType instanceof graphql.GraphQLList) originType = originType.ofType;
+			return new graphql.GraphQLNonNull(new graphql.GraphQLList(originType));
+		}
+	};
 }
+/**
+* Nullable Silk.
+*/
 function nullableSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql5.GraphQLNonNull) {
-        return originType.ofType;
-      } else {
-        return originType;
-      }
-    }
-  };
+	return {
+		...origin,
+		[require_context.GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof graphql.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 (require_context.GET_GRAPHQL_TYPE in silk$1 && silk$1[require_context.GET_GRAPHQL_TYPE] != null) return silk$1[require_context.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 (require_context.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
-var import_graphql6 = require("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 import_graphql6.GraphQLError(issues?.[0]?.message ?? "Invalid input", {
-      extensions: { issues }
-    });
-  }
-  if ("value" in result) return result.value;
-  else throw new import_graphql6.GraphQLError("Invalid input");
+	if (result == null) return result;
+	const { issues } = result;
+	if (issues?.length) throw new graphql.GraphQLError(issues?.[0]?.message ?? "Invalid input", { extensions: { issues } });
+	if ("value" in result) return result.value;
+	else throw new graphql.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 = require_context.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, { [require_context.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: require_context.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 = {
+			[require_context.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 === require_context.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 = {
+			[require_context.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
-var import_graphql8 = require("graphql");
-
-// src/schema/input.ts
-var import_graphql7 = require("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 ((0, import_graphql7.isNonNullType)(inputType)) inputType = inputType.ofType;
-    if ((0, import_graphql7.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, 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 ((0, graphql.isNonNullType)(inputType)) inputType = inputType.ofType;
+		if ((0, graphql.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 ((0, import_graphql7.isUnionType)(gqlType))
-    throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
-  if ((0, import_graphql7.isNonNullType)(gqlType)) {
-    return new import_graphql7.GraphQLNonNull(ensureInputType(gqlType.ofType, options));
-  }
-  if ((0, import_graphql7.isListType)(gqlType)) {
-    return new import_graphql7.GraphQLList(ensureInputType(gqlType.ofType, options));
-  }
-  if ((0, import_graphql7.isObjectType)(gqlType) || (0, import_graphql7.isInterfaceType)(gqlType))
-    return ensureInputObjectType(gqlType, options);
-  return gqlType;
+	const gqlType = (() => {
+		if (isSilk(silkOrType)) return getGraphQLType(silkOrType);
+		return silkOrType;
+	})();
+	if ((0, graphql.isUnionType)(gqlType)) throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
+	if ((0, graphql.isNonNullType)(gqlType)) return new graphql.GraphQLNonNull(ensureInputType(gqlType.ofType, options));
+	if ((0, graphql.isListType)(gqlType)) return new graphql.GraphQLList(ensureInputType(gqlType.ofType, options));
+	if ((0, graphql.isObjectType)(gqlType) || (0, graphql.isInterfaceType)(gqlType)) return ensureInputObjectType(gqlType, options);
+	return gqlType;
 }
 function ensureInputObjectType(object, options) {
-  if ((0, import_graphql7.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 import_graphql7.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 ((0, graphql.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 graphql.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 import_graphql8.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 ((0, import_graphql8.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, 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 graphql.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 ((0, graphql.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 = (0, import_graphql8.resolveObjMapThunk)(fields);
-  return mapValue(fieldMap, (fieldConfig, fieldName) => {
-    const argsConfig = fieldConfig.args ?? {};
-    return {
-      name: (0, import_graphql8.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 = (0, graphql.resolveObjMapThunk)(fields);
+	return mapValue(fieldMap, (fieldConfig, fieldName) => {
+		const argsConfig = fieldConfig.args ?? {};
+		return {
+			name: (0, graphql.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: (0, import_graphql8.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: (0, graphql.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 ((0, import_graphql8.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 ((0, import_graphql8.isListType)(gqlType)) {
-    return new import_graphql8.GraphQLList(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql8.isNonNullType)(gqlType)) {
-    return new import_graphql8.GraphQLNonNull(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql8.isUnionType)(gqlType)) {
-    const existing = context.loomUnionMap?.get(gqlType);
-    if (existing != null) return existing;
-    const config = gqlType.toConfig();
-    const unionType = new import_graphql8.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 ((0, graphql.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 ((0, graphql.isListType)(gqlType)) return new graphql.GraphQLList(getCacheType(gqlType.ofType, options));
+	else if ((0, graphql.isNonNullType)(gqlType)) return new graphql.GraphQLNonNull(getCacheType(gqlType.ofType, options));
+	else if ((0, graphql.isUnionType)(gqlType)) {
+		const existing = context.loomUnionMap?.get(gqlType);
+		if (existing != null) return existing;
+		const config = gqlType.toConfig();
+		const unionType = new graphql.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
-var import_graphql9 = require("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 ((0, import_graphql9.isNonNullType)(gqlType2)) gqlType2 = gqlType2.ofType;
-      if ((0, import_graphql9.isObjectType)(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 ((0, import_graphql9.isUnionType)(gqlType2) || (0, import_graphql9.isEnumType)(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 import_graphql9.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 ((0, import_graphql9.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
-      if (!(0, import_graphql9.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(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,
+			[require_context.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 ((0, graphql.isNonNullType)(gqlType$1)) gqlType$1 = gqlType$1.ofType;
+			if ((0, graphql.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 ((0, graphql.isUnionType)(gqlType$1) || (0, graphql.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 graphql.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 ((0, graphql.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
+			if (!(0, graphql.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 === require_context.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 (require_context.WEAVER_CONFIG in item) {
+				configs.add(item);
+				if (item.vendorWeaver) weavers.add(item.vendorWeaver);
+				if (item[require_context.WEAVER_CONFIG] === "gqloom.core.schema") context = item.weaverContext;
+			} else if (isSilk(item)) silks.add(item);
+			else if (item["~meta"][require_context.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
-var import_graphql10 = require("graphql");
+//#endregion
+//#region src/schema/interface.ts
 function ensureInterfaceType(gqlType, interfaceConfig) {
-  if ((0, import_graphql10.isInterfaceType)(gqlType)) return gqlType;
-  if (!(0, import_graphql10.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 import_graphql10.GraphQLInterfaceType({
-    ...config,
-    ...interfaceConfig,
-    fields: mapValue(fields, (field2) => {
-      return { ...field2, type: getCacheType(field2.type) };
-    })
-  });
-  weaverContext.interfaceMap?.set(key, interfaceType);
-  return interfaceType;
+	if ((0, graphql.isInterfaceType)(gqlType)) return gqlType;
+	if (!(0, graphql.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 graphql.GraphQLInterfaceType({
+		...config,
+		...interfaceConfig,
+		fields: mapValue(fields, (field$1) => {
+			return {
+				...field$1,
+				type: getCacheType(field$1.type)
+			};
+		})
+	});
+	weaverContext.interfaceMap?.set(key, interfaceType);
+	return interfaceType;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BaseChainFactory,
-  ChainResolver,
-  EasyDataLoader,
-  FieldChainFactory,
-  FieldFactoryWithResolve,
-  GraphQLSchemaLoom,
-  LoomDataLoader,
-  LoomObjectType,
-  MutationChainFactory,
-  MutationFactoryWithResolve,
-  OPERATION_OBJECT_NAMES,
-  ObjectChainResolver,
-  QueryChainFactory,
-  QueryFactoryWithResolve,
-  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
+exports.BaseChainFactory = BaseChainFactory;
+exports.ChainResolver = ChainResolver;
+exports.EasyDataLoader = EasyDataLoader;
+exports.FieldChainFactory = FieldChainFactory;
+exports.FieldFactoryWithResolve = FieldFactoryWithResolve;
+exports.GraphQLSchemaLoom = GraphQLSchemaLoom;
+exports.LoomDataLoader = LoomDataLoader;
+exports.LoomObjectType = LoomObjectType;
+exports.MutationChainFactory = MutationChainFactory;
+exports.MutationFactoryWithResolve = MutationFactoryWithResolve;
+exports.OPERATION_OBJECT_NAMES = OPERATION_OBJECT_NAMES;
+exports.ObjectChainResolver = ObjectChainResolver;
+exports.QueryChainFactory = QueryChainFactory;
+exports.QueryFactoryWithResolve = QueryFactoryWithResolve;
+Object.defineProperty(exports, 'SYMBOLS', {
+  enumerable: true,
+  get: function () {
+    return require_context.symbols_exports;
+  }
 });
+exports.SubscriptionChainFactory = SubscriptionChainFactory;
+exports.applyMiddlewares = applyMiddlewares;
+exports.assignContextMap = require_context.assignContextMap;
+exports.capitalize = capitalize;
+exports.collectName = collectName;
+exports.collectNames = collectNames;
+exports.createField = createField;
+exports.createInputParser = createInputParser;
+exports.createMutation = createMutation;
+exports.createQuery = createQuery;
+exports.createSubscription = createSubscription;
+exports.deepMerge = deepMerge;
+exports.defaultSubscriptionResolve = defaultSubscriptionResolve;
+exports.ensureInputObjectType = ensureInputObjectType;
+exports.ensureInputType = ensureInputType;
+exports.ensureInterfaceType = ensureInterfaceType;
+exports.field = field;
+exports.filterMiddlewares = filterMiddlewares;
+exports.getCacheType = getCacheType;
+exports.getDeepResolvingFields = require_context.getDeepResolvingFields;
+exports.getFieldOptions = getFieldOptions;
+exports.getGraphQLType = getGraphQLType;
+exports.getMemoizationMap = require_context.getMemoizationMap;
+exports.getOperationOptions = getOperationOptions;
+exports.getResolvingFields = require_context.getResolvingFields;
+exports.getStandardValue = getStandardValue;
+exports.getSubscriptionOptions = getSubscriptionOptions;
+exports.initWeaverContext = initWeaverContext;
+exports.inputToArgs = inputToArgs;
+exports.isOnlyMemoryPayload = require_context.isOnlyMemoryPayload;
+exports.isSchemaVendorWeaver = isSchemaVendorWeaver;
+exports.isSilk = isSilk;
+exports.listSilk = listSilk;
+exports.loom = loom;
+exports.mapValue = mapValue;
+exports.markErrorLocation = markErrorLocation;
+exports.markLocation = markLocation;
+exports.meta = meta;
+exports.mutation = mutation;
+exports.nonNullSilk = nonNullSilk;
+exports.notNullish = notNullish;
+exports.nullableSilk = nullableSilk;
+exports.onlyMemoization = require_context.onlyMemoization;
+exports.parseInputValue = parseInputValue;
+exports.parseResolvingFields = require_context.parseResolvingFields;
+exports.parseSilk = parseSilk;
+exports.pascalCase = pascalCase;
+exports.provideWeaverContext = provideWeaverContext;
+exports.query = query;
+exports.resolver = resolver;
+exports.screamingSnakeCase = screamingSnakeCase;
+exports.silk = silk;
+exports.subscription = subscription;
+exports.toObjMap = toObjMap;
+exports.tryIn = tryIn;
+exports.weave = weave;
+exports.weaverContext = weaverContext;