@effect-gql/core 0.1.0 → 1.0.0

package/index.cjs

@@ -0,0 +1,3419 @@
+'use strict';
+
+var graphql = require('graphql');
+var effect = require('effect');
+var S2 = require('effect/Schema');
+var AST = require('effect/SchemaAST');
+var DataLoader = require('dataloader');
+var platform = require('@effect/platform');
+var graphqlWs = require('graphql-ws');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var S2__namespace = /*#__PURE__*/_interopNamespace(S2);
+var AST__namespace = /*#__PURE__*/_interopNamespace(AST);
+var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
+
+// src/builder/index.ts
+var isIntegerType = (ast) => {
+  if (ast._tag === "Refinement") {
+    const refinement = ast;
+    const annotations = refinement.annotations;
+    if (annotations) {
+      const identifier = AST__namespace.getIdentifierAnnotation(refinement);
+      if (identifier._tag === "Some" && identifier.value === "Int") {
+        return true;
+      }
+    }
+    return isIntegerType(refinement.from);
+  }
+  return false;
+};
+var toGraphQLType = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "StringKeyword") return graphql.GraphQLString;
+  if (ast._tag === "NumberKeyword") return graphql.GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return graphql.GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return graphql.GraphQLInt;
+    }
+    return toGraphQLType(S2__namespace.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return graphql.GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? graphql.GraphQLInt : graphql.GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return graphql.GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2__namespace.make(elements[0].type);
+      return new graphql.GraphQLList(toGraphQLType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new graphql.GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Object_${Math.random().toString(36).slice(2, 11)}`;
+    return new graphql.GraphQLObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLType(S2__namespace.make(ast.to));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLType(S2__namespace.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLType(S2__namespace.make(innerAst));
+  }
+  return graphql.GraphQLString;
+};
+var toGraphQLInputType = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "StringKeyword") return graphql.GraphQLString;
+  if (ast._tag === "NumberKeyword") return graphql.GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return graphql.GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return graphql.GraphQLInt;
+    }
+    return toGraphQLInputType(S2__namespace.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return graphql.GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? graphql.GraphQLInt : graphql.GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return graphql.GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2__namespace.make(elements[0].type);
+      return new graphql.GraphQLList(toGraphQLInputType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new graphql.GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Input_${Math.random().toString(36).slice(2, 11)}`;
+    return new graphql.GraphQLInputObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLInputType(S2__namespace.make(ast.from));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLInputType(S2__namespace.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLInputType(S2__namespace.make(innerAst));
+  }
+  return graphql.GraphQLString;
+};
+var toGraphQLObjectType = (name, schema, additionalFields) => {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new graphql.GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    if (additionalFields) {
+      for (const [fieldName, fieldConfig] of Object.entries(additionalFields)) {
+        fields[fieldName] = {
+          type: fieldConfig.type,
+          args: fieldConfig.args,
+          description: fieldConfig.description,
+          // Note: resolve will be set later when runtime is available
+          resolve: fieldConfig.resolve
+        };
+      }
+    }
+    return new graphql.GraphQLObjectType({
+      name,
+      fields
+    });
+  }
+  throw new Error(`Schema must be an object type to convert to GraphQLObjectType`);
+};
+var toGraphQLArgs = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const args = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new graphql.GraphQLNonNull(fieldType);
+      }
+      args[fieldName] = { type: fieldType };
+    }
+    return args;
+  }
+  throw new Error(`Schema must be an object type to convert to GraphQL arguments`);
+};
+
+// src/builder/type-registry.ts
+function getSchemaName(schema) {
+  const ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    const identifier = AST__namespace.getIdentifierAnnotation(ast.to);
+    if (identifier._tag === "Some") {
+      return identifier.value;
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const tagProp = ast.propertySignatures.find((p) => String(p.name) === "_tag");
+    if (tagProp && tagProp.type._tag === "Literal" && typeof tagProp.type.literal === "string") {
+      return tagProp.type.literal;
+    }
+  }
+  return void 0;
+}
+function buildReverseLookups(ctx) {
+  if (!ctx.schemaToTypeName) {
+    ctx.schemaToTypeName = /* @__PURE__ */ new Map();
+    ctx.astToTypeName = /* @__PURE__ */ new Map();
+    for (const [typeName, typeReg] of ctx.types) {
+      ctx.schemaToTypeName.set(typeReg.schema, typeName);
+      ctx.astToTypeName.set(typeReg.schema.ast, typeName);
+    }
+  }
+  if (!ctx.schemaToInterfaceName) {
+    ctx.schemaToInterfaceName = /* @__PURE__ */ new Map();
+    ctx.astToInterfaceName = /* @__PURE__ */ new Map();
+    for (const [interfaceName, interfaceReg] of ctx.interfaces) {
+      ctx.schemaToInterfaceName.set(interfaceReg.schema, interfaceName);
+      ctx.astToInterfaceName.set(interfaceReg.schema.ast, interfaceName);
+    }
+  }
+  if (!ctx.schemaToInputName) {
+    ctx.schemaToInputName = /* @__PURE__ */ new Map();
+    ctx.astToInputName = /* @__PURE__ */ new Map();
+    for (const [inputName, inputReg] of ctx.inputs) {
+      ctx.schemaToInputName.set(inputReg.schema, inputName);
+      ctx.astToInputName.set(inputReg.schema.ast, inputName);
+    }
+  }
+  if (!ctx.enumSortedValues) {
+    ctx.enumSortedValues = /* @__PURE__ */ new Map();
+    ctx.literalToEnumName = /* @__PURE__ */ new Map();
+    for (const [enumName, enumReg] of ctx.enums) {
+      ctx.enumSortedValues.set(enumName, [...enumReg.values].sort());
+      for (const value of enumReg.values) {
+        ctx.literalToEnumName.set(value, enumName);
+      }
+    }
+  }
+  if (!ctx.unionSortedTypes) {
+    ctx.unionSortedTypes = /* @__PURE__ */ new Map();
+    for (const [unionName, unionReg] of ctx.unions) {
+      ctx.unionSortedTypes.set(unionName, [...unionReg.types].sort());
+    }
+  }
+}
+var nonNullCache = /* @__PURE__ */ new WeakMap();
+function getNonNull(type) {
+  let cached = nonNullCache.get(type);
+  if (!cached) {
+    cached = new graphql.GraphQLNonNull(type);
+    nonNullCache.set(type, cached);
+  }
+  return cached;
+}
+function toGraphQLTypeWithRegistry(schema, ctx) {
+  buildReverseLookups(ctx);
+  const ast = schema.ast;
+  const registeredType = findRegisteredType(schema, ast, ctx);
+  if (registeredType) return registeredType;
+  const registeredInterface = findRegisteredInterface(schema, ast, ctx);
+  if (registeredInterface) return registeredInterface;
+  if (ast._tag === "Transformation") {
+    return handleTransformationAST(ast, ctx);
+  }
+  if (ast._tag === "Union") {
+    return handleUnionAST(ast, ctx);
+  }
+  if (ast._tag === "Literal") {
+    const enumType2 = findEnumForLiteral(ast, ctx);
+    if (enumType2) return enumType2;
+  }
+  if (ast._tag === "TupleType") {
+    return handleTupleTypeAST(ast, ctx);
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLTypeWithRegistry(S2__namespace.make(innerAst), ctx);
+  }
+  return toGraphQLType(schema);
+}
+function findRegisteredType(schema, ast, ctx) {
+  const typeName = ctx.schemaToTypeName?.get(schema) ?? ctx.astToTypeName?.get(ast);
+  if (typeName) {
+    return ctx.typeRegistry.get(typeName);
+  }
+  return void 0;
+}
+function findRegisteredInterface(schema, ast, ctx) {
+  const interfaceName = ctx.schemaToInterfaceName?.get(schema) ?? ctx.astToInterfaceName?.get(ast);
+  if (interfaceName) {
+    return ctx.interfaceRegistry.get(interfaceName);
+  }
+  return void 0;
+}
+function handleTransformationAST(ast, ctx) {
+  const toAst = ast.to;
+  if (toAst._tag === "TupleType") {
+    if (toAst.rest && toAst.rest.length > 0) {
+      const elementSchema = S2__namespace.make(toAst.rest[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new graphql.GraphQLList(elementType);
+    } else if (toAst.elements.length > 0) {
+      const elementSchema = S2__namespace.make(toAst.elements[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new graphql.GraphQLList(elementType);
+    }
+  }
+  return toGraphQLTypeWithRegistry(S2__namespace.make(ast.to), ctx);
+}
+function handleUnionAST(ast, ctx) {
+  const allLiterals = ast.types.every((t) => t._tag === "Literal");
+  if (allLiterals) {
+    const enumType2 = findEnumForLiteralUnion(ast.types, ctx);
+    if (enumType2) return enumType2;
+  } else {
+    const unionType2 = findRegisteredUnion(ast.types, ctx);
+    if (unionType2) return unionType2;
+  }
+  if (ast.types.length > 0) {
+    return toGraphQLTypeWithRegistry(S2__namespace.make(ast.types[0]), ctx);
+  }
+  return toGraphQLType(S2__namespace.make(ast));
+}
+function findEnumForLiteralUnion(types, ctx) {
+  const literalValues = types.map((t) => String(t.literal)).sort();
+  for (const [enumName] of ctx.enums) {
+    const enumValues = ctx.enumSortedValues?.get(enumName);
+    if (enumValues && literalValues.length === enumValues.length && literalValues.every((v, i) => v === enumValues[i])) {
+      return ctx.enumRegistry.get(enumName);
+    }
+  }
+  return void 0;
+}
+function findRegisteredUnion(types, ctx) {
+  const memberTags = [];
+  for (const memberAst of types) {
+    if (memberAst._tag === "TypeLiteral") {
+      const tagProp = memberAst.propertySignatures.find((p) => String(p.name) === "_tag");
+      if (tagProp && tagProp.type._tag === "Literal") {
+        memberTags.push(String(tagProp.type.literal));
+      }
+    }
+  }
+  if (memberTags.length === types.length) {
+    const sortedTags = memberTags.sort();
+    for (const [unionName] of ctx.unions) {
+      const unionTypes = ctx.unionSortedTypes?.get(unionName);
+      if (unionTypes && sortedTags.length === unionTypes.length && sortedTags.every((tag, i) => tag === unionTypes[i])) {
+        return ctx.unionRegistry.get(unionName);
+      }
+    }
+  }
+  return void 0;
+}
+function findEnumForLiteral(ast, ctx) {
+  const literalValue = String(ast.literal);
+  const enumName = ctx.literalToEnumName?.get(literalValue);
+  if (enumName) {
+    return ctx.enumRegistry.get(enumName);
+  }
+  return void 0;
+}
+function handleTupleTypeAST(ast, ctx) {
+  if (ast.rest && ast.rest.length > 0) {
+    const elementSchema = S2__namespace.make(ast.rest[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new graphql.GraphQLList(elementType);
+  } else if (ast.elements && ast.elements.length > 0) {
+    const elementSchema = S2__namespace.make(ast.elements[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new graphql.GraphQLList(elementType);
+  }
+  return toGraphQLType(S2__namespace.make(ast));
+}
+function schemaToFields(schema, ctx) {
+  let ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    ast = ast.to;
+  }
+  if (ast._tag === "Declaration") {
+    const typeParams = ast.typeParameters;
+    if (typeParams && typeParams.length > 0 && typeParams[0]._tag === "TypeLiteral") {
+      ast = typeParams[0];
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLTypeWithRegistry(fieldSchema, ctx);
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    return fields;
+  }
+  return {};
+}
+function schemaToInputFields(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLInputTypeWithRegistry(
+        fieldSchema,
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    return fields;
+  }
+  return {};
+}
+function buildInputTypeLookupCache(inputs, enums) {
+  const cache = {
+    schemaToInputName: /* @__PURE__ */ new Map(),
+    astToInputName: /* @__PURE__ */ new Map(),
+    literalToEnumName: /* @__PURE__ */ new Map(),
+    enumSortedValues: /* @__PURE__ */ new Map()
+  };
+  for (const [inputName, inputReg] of inputs) {
+    cache.schemaToInputName.set(inputReg.schema, inputName);
+    cache.astToInputName.set(inputReg.schema.ast, inputName);
+  }
+  for (const [enumName, enumReg] of enums) {
+    cache.enumSortedValues.set(enumName, [...enumReg.values].sort());
+    for (const value of enumReg.values) {
+      cache.literalToEnumName.set(value, enumName);
+    }
+  }
+  return cache;
+}
+function toGraphQLInputTypeWithRegistry(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    const toAst = ast.to;
+    return toGraphQLInputTypeWithRegistry(
+      S2__namespace.make(toAst),
+      enumRegistry,
+      inputRegistry,
+      inputs,
+      enums,
+      cache
+    );
+  }
+  if (cache?.schemaToInputName || cache?.astToInputName) {
+    const inputName = cache.schemaToInputName?.get(schema) ?? cache.astToInputName?.get(ast);
+    if (inputName) {
+      const result = inputRegistry.get(inputName);
+      if (result) return result;
+    }
+  } else {
+    for (const [inputName, inputReg] of inputs) {
+      if (inputReg.schema.ast === ast || inputReg.schema === schema) {
+        const result = inputRegistry.get(inputName);
+        if (result) return result;
+      }
+    }
+  }
+  if (ast._tag === "Union") {
+    const unionAst = ast;
+    const nonUndefinedTypes = unionAst.types.filter((t) => t._tag !== "UndefinedKeyword");
+    if (nonUndefinedTypes.length === 1 && nonUndefinedTypes[0]._tag === "Union") {
+      return toGraphQLInputTypeWithRegistry(
+        S2__namespace.make(nonUndefinedTypes[0]),
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+    }
+    if (nonUndefinedTypes.length === 1 && nonUndefinedTypes[0]._tag === "TypeLiteral") {
+      return toGraphQLInputTypeWithRegistry(
+        S2__namespace.make(nonUndefinedTypes[0]),
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+    }
+    const allLiterals = unionAst.types.every((t) => t._tag === "Literal");
+    if (allLiterals) {
+      const literalValues = unionAst.types.map((t) => String(t.literal)).sort();
+      for (const [enumName] of enums) {
+        const enumValues = cache?.enumSortedValues?.get(enumName) ?? [...enums.get(enumName).values].sort();
+        if (literalValues.length === enumValues.length && literalValues.every((v, i) => v === enumValues[i])) {
+          const result = enumRegistry.get(enumName);
+          if (result) return result;
+        }
+      }
+    }
+  }
+  if (ast._tag === "Literal") {
+    const literalValue = String(ast.literal);
+    if (cache?.literalToEnumName) {
+      const enumName = cache.literalToEnumName.get(literalValue);
+      if (enumName) {
+        const result = enumRegistry.get(enumName);
+        if (result) return result;
+      }
+    } else {
+      for (const [enumName, enumReg] of enums) {
+        if (enumReg.values.includes(literalValue)) {
+          const result = enumRegistry.get(enumName);
+          if (result) return result;
+        }
+      }
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLInputTypeWithRegistry(
+      S2__namespace.make(innerAst),
+      enumRegistry,
+      inputRegistry,
+      inputs,
+      enums,
+      cache
+    );
+  }
+  return toGraphQLInputType(schema);
+}
+function toGraphQLArgsWithRegistry(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const args = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2__namespace.make(field2.type);
+      let fieldType = toGraphQLInputTypeWithRegistry(
+        fieldSchema,
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      args[fieldName] = { type: fieldType };
+    }
+    return args;
+  }
+  return toGraphQLArgs(schema);
+}
+function applyDirectives(effect, directives, directiveRegistrations) {
+  if (!directives) return effect;
+  let wrapped = effect;
+  for (const directiveApp of directives) {
+    const directiveReg = directiveRegistrations.get(directiveApp.name);
+    if (directiveReg?.apply) {
+      wrapped = directiveReg.apply(directiveApp.args ?? {})(wrapped);
+    }
+  }
+  return wrapped;
+}
+function applyMiddleware(effect, context, middlewares) {
+  if (middlewares.length === 0) return effect;
+  let wrapped = effect;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    const middleware2 = middlewares[i];
+    if (middleware2.match && !middleware2.match(context.info)) {
+      continue;
+    }
+    wrapped = middleware2.apply(wrapped, context);
+  }
+  return wrapped;
+}
+function buildField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    resolve: async (_parent, args, context, info) => {
+      let effect$1 = applyDirectives(
+        config.resolve(args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent: _parent, args, info };
+      effect$1 = applyMiddleware(effect$1, middlewareContext, ctx.middlewares);
+      return await effect.Runtime.runPromise(context.runtime)(effect$1);
+    }
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function buildObjectField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    resolve: async (parent, args, context, info) => {
+      let effect$1 = applyDirectives(
+        config.resolve(parent, args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent, args, info };
+      effect$1 = applyMiddleware(effect$1, middlewareContext, ctx.middlewares);
+      return await effect.Runtime.runPromise(context.runtime)(effect$1);
+    }
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function buildSubscriptionField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    // The subscribe function returns an AsyncIterator
+    subscribe: async (_parent, args, context, info) => {
+      let subscribeEffect = config.subscribe(args);
+      subscribeEffect = applyDirectives(
+        subscribeEffect,
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent: _parent, args, info };
+      subscribeEffect = applyMiddleware(subscribeEffect, middlewareContext, ctx.middlewares);
+      const stream = await effect.Runtime.runPromise(context.runtime)(subscribeEffect);
+      return streamToAsyncIterator(stream, context.runtime);
+    },
+    // The resolve function transforms each yielded value
+    // If no custom resolve is provided, return the payload directly
+    resolve: config.resolve ? async (value, args, context, info) => {
+      let effect$1 = config.resolve(value, args);
+      const middlewareContext = { parent: value, args, info };
+      effect$1 = applyMiddleware(effect$1, middlewareContext, ctx.middlewares);
+      return await effect.Runtime.runPromise(context.runtime)(effect$1);
+    } : (value) => value
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function streamToAsyncIterator(stream, runtime) {
+  let queue;
+  let fiber;
+  let initialized = false;
+  let done = false;
+  const initialize = async () => {
+    if (initialized) return;
+    initialized = true;
+    queue = await effect.Runtime.runPromise(runtime)(effect.Queue.unbounded());
+    fiber = effect.Runtime.runFork(runtime)(
+      effect.Effect.ensuring(
+        effect.Stream.runForEach(stream, (value) => effect.Queue.offer(queue, effect.Option.some(value))),
+        // Signal completion by pushing None
+        effect.Queue.offer(queue, effect.Option.none())
+      )
+    );
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      await initialize();
+      if (done) {
+        return { done: true, value: void 0 };
+      }
+      try {
+        const optionValue = await effect.Runtime.runPromise(runtime)(effect.Queue.take(queue));
+        if (effect.Option.isNone(optionValue)) {
+          done = true;
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: optionValue.value };
+      } catch (error) {
+        done = true;
+        throw error;
+      }
+    },
+    async return() {
+      done = true;
+      if (initialized) {
+        try {
+          await effect.Runtime.runPromise(runtime)(
+            effect.Fiber.interrupt(fiber)
+          );
+          await effect.Runtime.runPromise(runtime)(effect.Queue.shutdown(queue));
+        } catch {
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+}
+
+// src/builder/schema-builder.ts
+function updateState(state, key, value) {
+  return { ...state, [key]: value };
+}
+var GraphQLSchemaBuilder = class _GraphQLSchemaBuilder {
+  constructor(state) {
+    this.state = state;
+  }
+  pipe() {
+    return effect.Pipeable.pipeArguments(this, arguments);
+  }
+  /**
+   * Create an empty schema builder
+   */
+  static empty = new _GraphQLSchemaBuilder({
+    types: /* @__PURE__ */ new Map(),
+    interfaces: /* @__PURE__ */ new Map(),
+    enums: /* @__PURE__ */ new Map(),
+    unions: /* @__PURE__ */ new Map(),
+    inputs: /* @__PURE__ */ new Map(),
+    directives: /* @__PURE__ */ new Map(),
+    middlewares: [],
+    extensions: [],
+    queries: /* @__PURE__ */ new Map(),
+    mutations: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map(),
+    objectFields: /* @__PURE__ */ new Map()
+  });
+  /**
+   * Create a new builder with updated state
+   */
+  with(newState) {
+    return new _GraphQLSchemaBuilder(newState);
+  }
+  // ============================================================================
+  // Registration Methods
+  // ============================================================================
+  /**
+   * Add a query field
+   */
+  query(name, config) {
+    const newQueries = new Map(this.state.queries);
+    newQueries.set(name, config);
+    return this.with(updateState(this.state, "queries", newQueries));
+  }
+  /**
+   * Add a mutation field
+   */
+  mutation(name, config) {
+    const newMutations = new Map(this.state.mutations);
+    newMutations.set(name, config);
+    return this.with(updateState(this.state, "mutations", newMutations));
+  }
+  /**
+   * Add a subscription field
+   *
+   * Subscriptions return a Stream that yields values over time.
+   * The subscribe function returns an Effect that produces a Stream.
+   *
+   * @example
+   * ```typescript
+   * builder.subscription("userCreated", {
+   *   type: User,
+   *   subscribe: Effect.gen(function*() {
+   *     const pubsub = yield* PubSubService
+   *     return pubsub.subscribe("USER_CREATED")
+   *   }),
+   * })
+   * ```
+   */
+  subscription(name, config) {
+    const newSubscriptions = new Map(this.state.subscriptions);
+    newSubscriptions.set(name, config);
+    return this.with(updateState(this.state, "subscriptions", newSubscriptions));
+  }
+  /**
+   * Register an object type from a schema
+   */
+  objectType(config) {
+    const { schema, implements: implementsInterfaces, directives, cacheControl, fields } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "objectType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newTypes = new Map(this.state.types);
+    newTypes.set(name, { name, schema, implements: implementsInterfaces, directives, cacheControl });
+    let newObjectFields = this.state.objectFields;
+    if (fields) {
+      newObjectFields = new Map(this.state.objectFields);
+      const typeFields = /* @__PURE__ */ new Map();
+      for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+        typeFields.set(fieldName, fieldConfig);
+      }
+      newObjectFields.set(name, typeFields);
+    }
+    return this.with({
+      ...this.state,
+      types: newTypes,
+      objectFields: newObjectFields
+    });
+  }
+  /**
+   * Register an interface type from a schema
+   */
+  interfaceType(config) {
+    const { schema, resolveType, directives } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "interfaceType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newInterfaces = new Map(this.state.interfaces);
+    newInterfaces.set(name, {
+      name,
+      schema,
+      resolveType: resolveType ?? ((value) => value._tag),
+      directives
+    });
+    return this.with(updateState(this.state, "interfaces", newInterfaces));
+  }
+  /**
+   * Register an enum type
+   */
+  enumType(config) {
+    const { name, values, description, directives } = config;
+    const newEnums = new Map(this.state.enums);
+    newEnums.set(name, { name, values, description, directives });
+    return this.with(updateState(this.state, "enums", newEnums));
+  }
+  /**
+   * Register a union type
+   */
+  unionType(config) {
+    const { name, types, resolveType, directives } = config;
+    const newUnions = new Map(this.state.unions);
+    newUnions.set(name, {
+      name,
+      types,
+      resolveType: resolveType ?? ((value) => value._tag),
+      directives
+    });
+    return this.with(updateState(this.state, "unions", newUnions));
+  }
+  /**
+   * Register an input type
+   */
+  inputType(config) {
+    const { schema, description, directives } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "inputType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newInputs = new Map(this.state.inputs);
+    newInputs.set(name, { name, schema, description, directives });
+    return this.with(updateState(this.state, "inputs", newInputs));
+  }
+  /**
+   * Register a directive
+   */
+  directive(config) {
+    const newDirectives = new Map(this.state.directives);
+    newDirectives.set(config.name, config);
+    return this.with(updateState(this.state, "directives", newDirectives));
+  }
+  /**
+   * Register a middleware
+   *
+   * Middleware wraps all resolvers (or those matching a pattern) and executes
+   * in an "onion" model - first registered middleware is the outermost layer.
+   *
+   * @param config.name - Middleware name (for debugging/logging)
+   * @param config.description - Optional description
+   * @param config.match - Optional predicate to filter which fields this applies to
+   * @param config.apply - Function that transforms the resolver Effect
+   *
+   * @example
+   * ```typescript
+   * builder.middleware({
+   *   name: "logging",
+   *   apply: (effect, ctx) => Effect.gen(function*() {
+   *     yield* Effect.logInfo(`Resolving ${ctx.info.fieldName}`)
+   *     const start = Date.now()
+   *     const result = yield* effect
+   *     yield* Effect.logInfo(`Resolved in ${Date.now() - start}ms`)
+   *     return result
+   *   })
+   * })
+   * ```
+   */
+  middleware(config) {
+    const newMiddlewares = [...this.state.middlewares, config];
+    return this.with({ ...this.state, middlewares: newMiddlewares });
+  }
+  /**
+   * Register an extension
+   *
+   * Extensions provide lifecycle hooks that run at each phase of request processing
+   * (parse, validate, execute) and can contribute data to the response's extensions field.
+   *
+   * @param config.name - Extension name (for debugging/logging)
+   * @param config.description - Optional description
+   * @param config.onParse - Called after query parsing
+   * @param config.onValidate - Called after validation
+   * @param config.onExecuteStart - Called before execution begins
+   * @param config.onExecuteEnd - Called after execution completes
+   *
+   * @example
+   * ```typescript
+   * builder.extension({
+   *   name: "tracing",
+   *   onExecuteStart: () => Effect.gen(function*() {
+   *     const ext = yield* ExtensionsService
+   *     yield* ext.set("tracing", { startTime: Date.now() })
+   *   }),
+   *   onExecuteEnd: () => Effect.gen(function*() {
+   *     const ext = yield* ExtensionsService
+   *     yield* ext.merge("tracing", { endTime: Date.now() })
+   *   }),
+   * })
+   * ```
+   */
+  extension(config) {
+    const newExtensions = [...this.state.extensions, config];
+    return this.with({ ...this.state, extensions: newExtensions });
+  }
+  /**
+   * Get the registered extensions for use by the execution layer
+   */
+  getExtensions() {
+    return this.state.extensions;
+  }
+  /**
+   * Add a computed/relational field to an object type
+   */
+  field(typeName, fieldName, config) {
+    const newObjectFields = new Map(this.state.objectFields);
+    const typeFields = newObjectFields.get(typeName) || /* @__PURE__ */ new Map();
+    typeFields.set(fieldName, config);
+    newObjectFields.set(typeName, typeFields);
+    return this.with(updateState(this.state, "objectFields", newObjectFields));
+  }
+  // ============================================================================
+  // Schema Building
+  // ============================================================================
+  /**
+   * Get the field complexity map for use in complexity validation.
+   * Maps "TypeName.fieldName" to the complexity value or function.
+   */
+  getFieldComplexities() {
+    const complexities = /* @__PURE__ */ new Map();
+    for (const [name, config] of this.state.queries) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Query.${name}`, config.complexity);
+      }
+    }
+    for (const [name, config] of this.state.mutations) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Mutation.${name}`, config.complexity);
+      }
+    }
+    for (const [name, config] of this.state.subscriptions) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Subscription.${name}`, config.complexity);
+      }
+    }
+    for (const [typeName, fields] of this.state.objectFields) {
+      for (const [fieldName, config] of fields) {
+        if (config.complexity !== void 0) {
+          complexities.set(`${typeName}.${fieldName}`, config.complexity);
+        }
+      }
+    }
+    return complexities;
+  }
+  /**
+   * Get the cache hint map for use in cache control calculation.
+   * Maps "TypeName.fieldName" to the cache hint for field-level hints,
+   * or "TypeName" to the cache hint for type-level hints.
+   */
+  getCacheHints() {
+    const hints = /* @__PURE__ */ new Map();
+    for (const [typeName, typeReg] of this.state.types) {
+      if (typeReg.cacheControl !== void 0) {
+        hints.set(typeName, typeReg.cacheControl);
+      }
+    }
+    for (const [name, config] of this.state.queries) {
+      if (config.cacheControl !== void 0) {
+        hints.set(`Query.${name}`, config.cacheControl);
+      }
+    }
+    for (const [name, config] of this.state.subscriptions) {
+      if (config.cacheControl !== void 0) {
+        hints.set(`Subscription.${name}`, config.cacheControl);
+      }
+    }
+    for (const [typeName, fields] of this.state.objectFields) {
+      for (const [fieldName, config] of fields) {
+        if (config.cacheControl !== void 0) {
+          hints.set(`${typeName}.${fieldName}`, config.cacheControl);
+        }
+      }
+    }
+    return hints;
+  }
+  /**
+   * Build the GraphQL schema (no services required)
+   */
+  buildSchema() {
+    const directiveRegistry = this.buildDirectiveRegistry();
+    const enumRegistry = this.buildEnumRegistry();
+    const inputRegistry = this.buildInputRegistry(enumRegistry);
+    const interfaceRegistry = this.buildInterfaceRegistry(enumRegistry);
+    const { typeRegistry, unionRegistry } = this.buildTypeAndUnionRegistries(
+      enumRegistry,
+      interfaceRegistry
+    );
+    const fieldCtx = this.createFieldBuilderContext(
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      inputRegistry
+    );
+    const queryFields = this.buildQueryFields(fieldCtx);
+    const mutationFields = this.buildMutationFields(fieldCtx);
+    const subscriptionFields = this.buildSubscriptionFields(fieldCtx);
+    return this.assembleSchema({
+      directiveRegistry,
+      enumRegistry,
+      inputRegistry,
+      interfaceRegistry,
+      typeRegistry,
+      unionRegistry,
+      queryFields,
+      mutationFields,
+      subscriptionFields
+    });
+  }
+  buildDirectiveRegistry() {
+    const registry = /* @__PURE__ */ new Map();
+    const cache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    for (const [name, reg] of this.state.directives) {
+      const graphqlDirective = new graphql.GraphQLDirective({
+        name,
+        description: reg.description,
+        locations: [...reg.locations],
+        args: reg.args ? toGraphQLArgsWithRegistry(
+          reg.args,
+          /* @__PURE__ */ new Map(),
+          /* @__PURE__ */ new Map(),
+          this.state.inputs,
+          this.state.enums,
+          cache
+        ) : void 0
+      });
+      registry.set(name, graphqlDirective);
+    }
+    return registry;
+  }
+  buildEnumRegistry() {
+    const registry = /* @__PURE__ */ new Map();
+    for (const [name, reg] of this.state.enums) {
+      const enumValues = {};
+      for (const value of reg.values) {
+        enumValues[value] = { value };
+      }
+      registry.set(
+        name,
+        new graphql.GraphQLEnumType({
+          name,
+          values: enumValues,
+          description: reg.description,
+          extensions: reg.directives ? { directives: reg.directives } : void 0
+        })
+      );
+    }
+    return registry;
+  }
+  buildInputRegistry(enumRegistry) {
+    const registry = /* @__PURE__ */ new Map();
+    const cache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    for (const [name, reg] of this.state.inputs) {
+      const inputType2 = new graphql.GraphQLInputObjectType({
+        name,
+        description: reg.description,
+        fields: () => schemaToInputFields(
+          reg.schema,
+          enumRegistry,
+          registry,
+          this.state.inputs,
+          this.state.enums,
+          cache
+        ),
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      registry.set(name, inputType2);
+    }
+    return registry;
+  }
+  buildInterfaceRegistry(enumRegistry) {
+    const registry = /* @__PURE__ */ new Map();
+    const typeRegistry = /* @__PURE__ */ new Map();
+    const unionRegistry = /* @__PURE__ */ new Map();
+    const sharedCtx = {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry: registry,
+      enumRegistry,
+      unionRegistry};
+    buildReverseLookups(sharedCtx);
+    for (const [name, reg] of this.state.interfaces) {
+      const interfaceType2 = new graphql.GraphQLInterfaceType({
+        name,
+        fields: () => schemaToFields(reg.schema, sharedCtx),
+        resolveType: reg.resolveType,
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      registry.set(name, interfaceType2);
+    }
+    return registry;
+  }
+  buildTypeAndUnionRegistries(enumRegistry, interfaceRegistry) {
+    const typeRegistry = /* @__PURE__ */ new Map();
+    const unionRegistry = /* @__PURE__ */ new Map();
+    const sharedCtx = {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry};
+    buildReverseLookups(sharedCtx);
+    const sharedFieldCtx = this.createFieldBuilderContext(
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      /* @__PURE__ */ new Map()
+    );
+    for (const [typeName, typeReg] of this.state.types) {
+      const implementedInterfaces = typeReg.implements?.map((name) => interfaceRegistry.get(name)).filter(Boolean) ?? [];
+      const graphqlType = new graphql.GraphQLObjectType({
+        name: typeName,
+        fields: () => {
+          const baseFields = schemaToFields(typeReg.schema, sharedCtx);
+          const additionalFields = this.state.objectFields.get(typeName);
+          if (additionalFields) {
+            for (const [fieldName, fieldConfig] of additionalFields) {
+              baseFields[fieldName] = buildObjectField(fieldConfig, sharedFieldCtx);
+            }
+          }
+          return baseFields;
+        },
+        interfaces: implementedInterfaces.length > 0 ? implementedInterfaces : void 0,
+        extensions: typeReg.directives ? { directives: typeReg.directives } : void 0
+      });
+      typeRegistry.set(typeName, graphqlType);
+    }
+    for (const [name, reg] of this.state.unions) {
+      const unionType2 = new graphql.GraphQLUnionType({
+        name,
+        types: () => reg.types.map((typeName) => typeRegistry.get(typeName)).filter(Boolean),
+        resolveType: reg.resolveType,
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      unionRegistry.set(name, unionType2);
+    }
+    return { typeRegistry, unionRegistry };
+  }
+  createFieldBuilderContext(typeRegistry, interfaceRegistry, enumRegistry, unionRegistry, inputRegistry) {
+    const inputTypeLookupCache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    return {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      inputRegistry,
+      directiveRegistrations: this.state.directives,
+      middlewares: this.state.middlewares,
+      inputTypeLookupCache
+    };
+  }
+  buildQueryFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.queries) {
+      fields[name] = buildField(config, ctx);
+    }
+    return fields;
+  }
+  buildMutationFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.mutations) {
+      fields[name] = buildField(config, ctx);
+    }
+    return fields;
+  }
+  buildSubscriptionFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.subscriptions) {
+      fields[name] = buildSubscriptionField(config, ctx);
+    }
+    return fields;
+  }
+  assembleSchema(registries) {
+    const schemaConfig = {
+      types: [
+        ...Array.from(registries.enumRegistry.values()),
+        ...Array.from(registries.inputRegistry.values()),
+        ...Array.from(registries.interfaceRegistry.values()),
+        ...Array.from(registries.typeRegistry.values()),
+        ...Array.from(registries.unionRegistry.values())
+      ],
+      directives: registries.directiveRegistry.size > 0 ? [...Array.from(registries.directiveRegistry.values())] : void 0
+    };
+    if (Object.keys(registries.queryFields).length > 0) {
+      schemaConfig.query = new graphql.GraphQLObjectType({
+        name: "Query",
+        fields: registries.queryFields
+      });
+    }
+    if (Object.keys(registries.mutationFields).length > 0) {
+      schemaConfig.mutation = new graphql.GraphQLObjectType({
+        name: "Mutation",
+        fields: registries.mutationFields
+      });
+    }
+    if (Object.keys(registries.subscriptionFields).length > 0) {
+      schemaConfig.subscription = new graphql.GraphQLObjectType({
+        name: "Subscription",
+        fields: registries.subscriptionFields
+      });
+    }
+    return new graphql.GraphQLSchema(schemaConfig);
+  }
+};
+
+// src/builder/pipe-api.ts
+var objectType = (config) => (builder) => builder.objectType(config);
+var interfaceType = (config) => (builder) => builder.interfaceType(config);
+var enumType = (config) => (builder) => builder.enumType(config);
+var unionType = (config) => (builder) => builder.unionType(config);
+var inputType = (config) => (builder) => builder.inputType(config);
+var directive = (config) => (builder) => builder.directive(config);
+var middleware = (config) => (builder) => builder.middleware(config);
+var extension = (config) => (builder) => builder.extension(config);
+var query = (name, config) => (builder) => builder.query(name, config);
+var mutation = (name, config) => (builder) => builder.mutation(name, config);
+var subscription = (name, config) => (builder) => builder.subscription(name, config);
+var field = (typeName, fieldName, config) => (builder) => builder.field(typeName, fieldName, config);
+var compose = (...operations) => (builder) => operations.reduce((b, op) => op(b), builder);
+var ExtensionsService = effect.Context.GenericTag(
+  "@effect-gql/ExtensionsService"
+);
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+var makeExtensionsService = () => effect.Effect.gen(function* () {
+  const ref = yield* effect.Ref.make({});
+  return ExtensionsService.of({
+    set: (key, value) => effect.Ref.update(ref, (current) => ({ ...current, [key]: value })),
+    merge: (key, value) => effect.Ref.update(ref, (current) => {
+      const existing = current[key];
+      if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+        return {
+          ...current,
+          [key]: deepMerge(existing, value)
+        };
+      }
+      return { ...current, [key]: value };
+    }),
+    get: () => effect.Ref.get(ref)
+  });
+});
+var runExtensionHooks = (extensions, hookName, getHookEffect) => effect.Effect.forEach(
+  extensions.filter((ext) => ext[hookName] !== void 0),
+  (ext) => getHookEffect(ext).pipe(
+    effect.Effect.catchAllCause(
+      (cause) => effect.Effect.logWarning(`Extension "${ext.name}" ${String(hookName)} hook failed`, cause)
+    )
+  ),
+  { discard: true }
+);
+var runParseHooks = (extensions, source, document) => runExtensionHooks(extensions, "onParse", (ext) => ext.onParse(source, document));
+var runValidateHooks = (extensions, document, errors) => runExtensionHooks(extensions, "onValidate", (ext) => ext.onValidate(document, errors));
+var runExecuteStartHooks = (extensions, args) => runExtensionHooks(extensions, "onExecuteStart", (ext) => ext.onExecuteStart(args));
+var runExecuteEndHooks = (extensions, result) => runExtensionHooks(extensions, "onExecuteEnd", (ext) => ext.onExecuteEnd(result));
+
+// src/builder/execute.ts
+var execute = (schema, layer, extensions = [], fieldComplexities = /* @__PURE__ */ new Map()) => (source, variableValues, operationName) => effect.Effect.gen(function* () {
+  const extensionsService = yield* makeExtensionsService();
+  const runtime = yield* effect.Effect.runtime();
+  let document;
+  try {
+    document = graphql.parse(source);
+  } catch (parseError) {
+    const extensionData2 = yield* extensionsService.get();
+    return {
+      errors: [
+        parseError instanceof graphql.GraphQLError ? parseError : new graphql.GraphQLError(String(parseError))
+      ],
+      extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+    };
+  }
+  yield* runParseHooks(extensions, source, document).pipe(
+    effect.Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const validationErrors = graphql.validate(schema, document);
+  yield* runValidateHooks(extensions, document, validationErrors).pipe(
+    effect.Effect.provideService(ExtensionsService, extensionsService)
+  );
+  if (validationErrors.length > 0) {
+    const extensionData2 = yield* extensionsService.get();
+    return {
+      errors: validationErrors,
+      extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+    };
+  }
+  const executionArgs = {
+    source,
+    document,
+    variableValues,
+    operationName,
+    schema,
+    fieldComplexities
+  };
+  yield* runExecuteStartHooks(extensions, executionArgs).pipe(
+    effect.Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const executeResult = yield* effect.Effect.try({
+    try: () => graphql.execute({
+      schema,
+      document,
+      variableValues,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  const resolvedResult = executeResult && typeof executeResult === "object" && "then" in executeResult ? yield* effect.Effect.promise(() => executeResult) : executeResult;
+  yield* runExecuteEndHooks(extensions, resolvedResult).pipe(
+    effect.Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const extensionData = yield* extensionsService.get();
+  if (Object.keys(extensionData).length > 0) {
+    return {
+      ...resolvedResult,
+      extensions: {
+        ...resolvedResult.extensions,
+        ...extensionData
+      }
+    };
+  }
+  return resolvedResult;
+}).pipe(effect.Effect.provide(layer));
+var GraphQLError2 = class extends effect.Data.TaggedError("GraphQLError") {
+};
+var ValidationError = class extends effect.Data.TaggedError("ValidationError") {
+};
+var AuthorizationError = class extends effect.Data.TaggedError("AuthorizationError") {
+};
+var NotFoundError = class extends effect.Data.TaggedError("NotFoundError") {
+};
+var GraphQLRequestContext = effect.Context.GenericTag("GraphQLRequestContext");
+var makeRequestContextLayer = (context) => effect.Layer.succeed(GraphQLRequestContext, context);
+function single(config) {
+  return {
+    _tag: "single",
+    batch: config.batch,
+    key: config.key
+  };
+}
+function grouped(config) {
+  return {
+    _tag: "grouped",
+    batch: config.batch,
+    groupBy: config.groupBy
+  };
+}
+var LoaderRegistry = class {
+  constructor(definitions) {
+    this.definitions = definitions;
+    this.Service = effect.Context.GenericTag(
+      `DataLoaders(${Object.keys(definitions).join(", ")})`
+    );
+  }
+  _tag = "LoaderRegistry";
+  /**
+   * The Effect service tag for this loader registry
+   */
+  Service;
+  /**
+   * Create a Layer that provides fresh DataLoader instances.
+   * Call this once per request to get request-scoped loaders.
+   */
+  toLayer() {
+    const self = this;
+    return effect.Layer.effect(
+      this.Service,
+      effect.Effect.gen(function* () {
+        const instances = {};
+        for (const [name, def] of Object.entries(self.definitions)) {
+          instances[name] = yield* createDataLoader(def);
+        }
+        return instances;
+      })
+    );
+  }
+  /**
+   * Helper to use loaders in a resolver with a callback.
+   */
+  use(fn) {
+    const self = this;
+    return effect.Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      return yield* effect.Effect.promise(() => fn(loaders));
+    });
+  }
+  /**
+   * Load a single value by key.
+   * This is the most common operation in resolvers.
+   */
+  load(name, key) {
+    const self = this;
+    return effect.Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      const loader = loaders[name];
+      return yield* effect.Effect.promise(() => loader.load(key));
+    });
+  }
+  /**
+   * Load multiple values by keys.
+   * All keys are batched into a single request.
+   */
+  loadMany(name, keys) {
+    const self = this;
+    return effect.Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      const loader = loaders[name];
+      const results = yield* effect.Effect.promise(() => loader.loadMany(keys));
+      for (const result of results) {
+        if (result instanceof Error) {
+          return yield* effect.Effect.fail(result);
+        }
+      }
+      return results;
+    });
+  }
+};
+function createDataLoader(def) {
+  return effect.Effect.gen(function* () {
+    const context = yield* effect.Effect.context();
+    if (def._tag === "single") {
+      const loader = new DataLoader__default.default(async (keys) => {
+        const items = await effect.Effect.runPromise(def.batch(keys).pipe(effect.Effect.provide(context)));
+        return keys.map((key) => {
+          const item = items.find((i) => def.key(i) === key);
+          if (!item) return new Error(`Not found: ${key}`);
+          return item;
+        });
+      });
+      return loader;
+    } else {
+      const loader = new DataLoader__default.default(async (keys) => {
+        const items = await effect.Effect.runPromise(def.batch(keys).pipe(effect.Effect.provide(context)));
+        const map = /* @__PURE__ */ new Map();
+        for (const item of items) {
+          const key = def.groupBy(item);
+          let arr = map.get(key);
+          if (!arr) {
+            arr = [];
+            map.set(key, arr);
+          }
+          arr.push(item);
+        }
+        return keys.map((key) => map.get(key) ?? []);
+      });
+      return loader;
+    }
+  });
+}
+function define(definitions) {
+  return new LoaderRegistry(definitions);
+}
+function mapByKey(keys, items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    map.set(keyFn(item), item);
+  }
+  return keys.map((key) => map.get(key) ?? new Error(`Not found: ${key}`));
+}
+function groupByKey(keys, items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    map.set(key, []);
+  }
+  for (const item of items) {
+    const key = keyFn(item);
+    const arr = map.get(key);
+    if (arr) arr.push(item);
+  }
+  return map;
+}
+var Loader = {
+  define,
+  single,
+  grouped,
+  mapByKey,
+  groupByKey
+};
+var MissingResolverContextError = class extends Error {
+  constructor(contextName) {
+    super(
+      `Resolver context "${contextName}" was not provided. Ensure a parent resolver or directive provides this context.`
+    );
+    this.contextName = contextName;
+    this.name = "MissingResolverContextError";
+  }
+  _tag = "MissingResolverContextError";
+};
+var ResolverContextStore = effect.Context.GenericTag(
+  "effect-gql/ResolverContextStore"
+);
+var makeStoreLayer = () => effect.Effect.map(
+  effect.Ref.make(effect.HashMap.empty()),
+  (ref) => effect.Layer.succeed(ResolverContextStore, { ref })
+);
+var storeLayer = effect.Layer.effect(
+  ResolverContextStore,
+  effect.Effect.map(effect.Ref.make(effect.HashMap.empty()), (ref) => ({ ref }))
+);
+var make3 = (name) => ({
+  _tag: "ResolverContextSlot",
+  name,
+  _A: void 0
+});
+var get = (slot) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Effect.flatMap(effect.Ref.get(store.ref), (map) => {
+    const value = effect.HashMap.get(map, slot.name);
+    return effect.Option.match(value, {
+      onNone: () => effect.Effect.fail(new MissingResolverContextError(slot.name)),
+      onSome: (v) => effect.Effect.succeed(v)
+    });
+  })
+);
+var getOption = (slot) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Effect.map(effect.Ref.get(store.ref), (map) => effect.HashMap.get(map, slot.name))
+);
+var set = (slot, value) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Ref.update(store.ref, (map) => effect.HashMap.set(map, slot.name, value))
+);
+var setMany = (values) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Ref.update(store.ref, (map) => {
+    let result = map;
+    for (const [slot, value] of values) {
+      result = effect.HashMap.set(result, slot.name, value);
+    }
+    return result;
+  })
+);
+var has = (slot) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Effect.map(effect.Ref.get(store.ref), (map) => effect.HashMap.has(map, slot.name))
+);
+var getOrElse = (slot, orElse) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Effect.map(
+    effect.Ref.get(store.ref),
+    (map) => effect.Option.getOrElse(effect.HashMap.get(map, slot.name), orElse)
+  )
+);
+var scoped = (slot, value) => (effect$1) => effect.Effect.flatMap(
+  ResolverContextStore,
+  (store) => effect.Effect.acquireUseRelease(
+    // Acquire: save current value and set new one
+    effect.Effect.flatMap(effect.Ref.get(store.ref), (map) => {
+      const previous = effect.HashMap.get(map, slot.name);
+      return effect.Effect.as(effect.Ref.set(store.ref, effect.HashMap.set(map, slot.name, value)), previous);
+    }),
+    // Use: run the effect
+    () => effect$1,
+    // Release: restore previous value
+    (previous) => effect.Ref.update(
+      store.ref,
+      (map) => effect.Option.match(previous, {
+        onNone: () => effect.HashMap.remove(map, slot.name),
+        onSome: (v) => effect.HashMap.set(map, slot.name, v)
+      })
+    )
+  )
+);
+var ResolverContext = {
+  make: make3,
+  get,
+  getOption,
+  set,
+  setMany,
+  has,
+  getOrElse,
+  scoped,
+  storeLayer,
+  makeStoreLayer,
+  Store: ResolverContextStore,
+  MissingResolverContextError
+};
+var defaultConfig = {
+  path: "/graphql",
+  graphiql: false,
+  complexity: void 0,
+  introspection: true,
+  cacheControl: void 0
+};
+var normalizeConfig = (input = {}) => {
+  const path = input.path ?? defaultConfig.path;
+  let graphiql = false;
+  if (input.graphiql === true) {
+    graphiql = { path: "/graphiql", endpoint: path };
+  } else if (input.graphiql && typeof input.graphiql === "object") {
+    graphiql = {
+      path: input.graphiql.path ?? "/graphiql",
+      endpoint: input.graphiql.endpoint ?? path
+    };
+  }
+  return {
+    path,
+    graphiql,
+    complexity: input.complexity,
+    introspection: input.introspection ?? true,
+    cacheControl: input.cacheControl
+  };
+};
+var GraphQLRouterConfigFromEnv = effect.Config.all({
+  path: effect.Config.string("GRAPHQL_PATH").pipe(effect.Config.withDefault("/graphql")),
+  introspection: effect.Config.boolean("GRAPHQL_INTROSPECTION").pipe(effect.Config.withDefault(true)),
+  graphiqlEnabled: effect.Config.boolean("GRAPHIQL_ENABLED").pipe(effect.Config.withDefault(false)),
+  graphiqlPath: effect.Config.string("GRAPHIQL_PATH").pipe(effect.Config.withDefault("/graphiql")),
+  graphiqlEndpoint: effect.Config.string("GRAPHIQL_ENDPOINT").pipe(effect.Config.option),
+  maxDepth: effect.Config.number("GRAPHQL_MAX_DEPTH").pipe(effect.Config.option),
+  maxComplexity: effect.Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(effect.Config.option),
+  maxAliases: effect.Config.number("GRAPHQL_MAX_ALIASES").pipe(effect.Config.option),
+  maxFields: effect.Config.number("GRAPHQL_MAX_FIELDS").pipe(effect.Config.option),
+  defaultFieldComplexity: effect.Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    effect.Config.withDefault(1)
+  ),
+  cacheControlEnabled: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(
+    effect.Config.withDefault(false)
+  ),
+  cacheControlDefaultMaxAge: effect.Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(
+    effect.Config.withDefault(0)
+  ),
+  cacheControlDefaultScope: effect.Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    effect.Config.withDefault("PUBLIC")
+  )
+}).pipe(
+  effect.Config.map(
+    ({
+      path,
+      introspection,
+      graphiqlEnabled,
+      graphiqlPath,
+      graphiqlEndpoint,
+      maxDepth,
+      maxComplexity,
+      maxAliases,
+      maxFields,
+      defaultFieldComplexity,
+      cacheControlEnabled,
+      cacheControlDefaultMaxAge,
+      cacheControlDefaultScope
+    }) => {
+      const hasComplexity = effect.Option.isSome(maxDepth) || effect.Option.isSome(maxComplexity) || effect.Option.isSome(maxAliases) || effect.Option.isSome(maxFields);
+      return {
+        path,
+        introspection,
+        graphiql: graphiqlEnabled ? {
+          path: graphiqlPath,
+          endpoint: effect.Option.isSome(graphiqlEndpoint) ? graphiqlEndpoint.value : path
+        } : false,
+        complexity: hasComplexity ? {
+          maxDepth: effect.Option.getOrUndefined(maxDepth),
+          maxComplexity: effect.Option.getOrUndefined(maxComplexity),
+          maxAliases: effect.Option.getOrUndefined(maxAliases),
+          maxFields: effect.Option.getOrUndefined(maxFields),
+          defaultFieldComplexity
+        } : void 0,
+        cacheControl: cacheControlEnabled ? {
+          enabled: true,
+          defaultMaxAge: cacheControlDefaultMaxAge,
+          defaultScope: cacheControlDefaultScope === "PRIVATE" ? "PRIVATE" : "PUBLIC",
+          calculateHttpHeaders: true
+        } : void 0
+      };
+    }
+  )
+);
+
+// src/server/graphiql.ts
+var graphiqlHtml = (endpoint) => `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>GraphiQL</title>
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/graphiql@3/graphiql.min.css"
+    />
+  </head>
+  <body style="margin: 0; overflow: hidden;">
+    <div id="graphiql" style="height: 100vh;"></div>
+    <script
+      crossorigin
+      src="https://unpkg.com/react@18/umd/react.production.min.js"
+    ></script>
+    <script
+      crossorigin
+      src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"
+    ></script>
+    <script
+      crossorigin
+      src="https://unpkg.com/graphiql@3/graphiql.min.js"
+    ></script>
+    <script>
+      const fetcher = GraphiQL.createFetcher({
+        url: ${JSON.stringify(endpoint)},
+      });
+      ReactDOM.createRoot(document.getElementById('graphiql')).render(
+        React.createElement(GraphiQL, { fetcher })
+      );
+    </script>
+  </body>
+</html>`;
+var ComplexityLimitExceededError = class extends effect.Data.TaggedError("ComplexityLimitExceededError") {
+};
+var ComplexityAnalysisError = class extends effect.Data.TaggedError("ComplexityAnalysisError") {
+};
+var defaultComplexityCalculator = (defaultCost = 1) => {
+  return (info) => effect.Effect.try({
+    try: () => {
+      const fragments = /* @__PURE__ */ new Map();
+      for (const definition of info.document.definitions) {
+        if (definition.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+          fragments.set(definition.name.value, definition);
+        }
+      }
+      const rootType = getRootType(info.schema, info.operation.operation);
+      if (!rootType) {
+        throw new Error(`No root type found for operation: ${info.operation.operation}`);
+      }
+      const result = analyzeSelectionSet(
+        info.operation.selectionSet,
+        rootType,
+        info.schema,
+        fragments,
+        info.fieldComplexities,
+        info.variables ?? {},
+        defaultCost,
+        1,
+        // Starting depth
+        /* @__PURE__ */ new Set()
+        // Visited fragments to prevent infinite loops
+      );
+      return result;
+    },
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to analyze query complexity: ${error}`,
+      cause: error
+    })
+  });
+};
+function getRootType(schema, operation) {
+  switch (operation) {
+    case "query":
+      return schema.getQueryType() ?? null;
+    case "mutation":
+      return schema.getMutationType() ?? null;
+    case "subscription":
+      return schema.getSubscriptionType() ?? null;
+  }
+}
+function getNamedType(type) {
+  if (type instanceof graphql.GraphQLNonNull || type instanceof graphql.GraphQLList) {
+    return getNamedType(type.ofType);
+  }
+  if (type instanceof graphql.GraphQLObjectType) {
+    return type;
+  }
+  return null;
+}
+function accumulateResult(acc, result) {
+  acc.maxDepth = Math.max(acc.maxDepth, result.depth);
+  acc.complexity += result.complexity;
+  acc.fieldCount += result.fieldCount;
+  acc.aliasCount += result.aliasCount;
+}
+function analyzeSelectionSet(selectionSet, parentType, schema, fragments, fieldComplexities, variables, defaultCost, currentDepth, visitedFragments) {
+  const ctx = { schema, fragments, fieldComplexities, variables, defaultCost };
+  const acc = { maxDepth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  for (const selection of selectionSet.selections) {
+    const result = analyzeSelection(selection, parentType, ctx, currentDepth, visitedFragments);
+    accumulateResult(acc, result);
+  }
+  return {
+    depth: acc.maxDepth,
+    complexity: acc.complexity,
+    fieldCount: acc.fieldCount,
+    aliasCount: acc.aliasCount
+  };
+}
+function analyzeSelection(selection, parentType, ctx, currentDepth, visitedFragments) {
+  switch (selection.kind) {
+    case graphql.Kind.FIELD:
+      return analyzeField(selection, parentType, ctx, currentDepth, visitedFragments);
+    case graphql.Kind.FRAGMENT_SPREAD:
+      return analyzeFragmentSpread(selection, ctx, currentDepth, visitedFragments);
+    case graphql.Kind.INLINE_FRAGMENT:
+      return analyzeInlineFragment(selection, parentType, ctx, currentDepth, visitedFragments);
+  }
+}
+function analyzeField(field2, parentType, ctx, currentDepth, visitedFragments) {
+  const fieldName = field2.name.value;
+  const aliasCount = field2.alias ? 1 : 0;
+  if (fieldName.startsWith("__")) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 1, aliasCount };
+  }
+  const schemaField = parentType.getFields()[fieldName];
+  if (!schemaField) {
+    return { depth: currentDepth, complexity: ctx.defaultCost, fieldCount: 1, aliasCount };
+  }
+  const args = resolveFieldArguments(field2, ctx.variables);
+  const complexityKey = `${parentType.name}.${fieldName}`;
+  const fieldComplexity = ctx.fieldComplexities.get(complexityKey);
+  const cost = fieldComplexity !== void 0 ? typeof fieldComplexity === "function" ? fieldComplexity(args) : fieldComplexity : ctx.defaultCost;
+  if (field2.selectionSet) {
+    const fieldType = getNamedType(schemaField.type);
+    if (fieldType) {
+      const nestedResult = analyzeSelectionSet(
+        field2.selectionSet,
+        fieldType,
+        ctx.schema,
+        ctx.fragments,
+        ctx.fieldComplexities,
+        ctx.variables,
+        ctx.defaultCost,
+        currentDepth + 1,
+        visitedFragments
+      );
+      return {
+        depth: nestedResult.depth,
+        complexity: cost + nestedResult.complexity,
+        fieldCount: 1 + nestedResult.fieldCount,
+        aliasCount: aliasCount + nestedResult.aliasCount
+      };
+    }
+  }
+  return { depth: currentDepth, complexity: cost, fieldCount: 1, aliasCount };
+}
+function analyzeFragmentSpread(spread, ctx, currentDepth, visitedFragments) {
+  const fragmentName = spread.name.value;
+  if (visitedFragments.has(fragmentName)) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const fragment = ctx.fragments.get(fragmentName);
+  if (!fragment) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const fragmentType = ctx.schema.getType(fragment.typeCondition.name.value);
+  if (!(fragmentType instanceof graphql.GraphQLObjectType)) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const newVisited = new Set(visitedFragments);
+  newVisited.add(fragmentName);
+  return analyzeSelectionSet(
+    fragment.selectionSet,
+    fragmentType,
+    ctx.schema,
+    ctx.fragments,
+    ctx.fieldComplexities,
+    ctx.variables,
+    ctx.defaultCost,
+    currentDepth,
+    newVisited
+  );
+}
+function analyzeInlineFragment(fragment, parentType, ctx, currentDepth, visitedFragments) {
+  let targetType = parentType;
+  if (fragment.typeCondition) {
+    const conditionType = ctx.schema.getType(fragment.typeCondition.name.value);
+    if (conditionType instanceof graphql.GraphQLObjectType) {
+      targetType = conditionType;
+    }
+  }
+  return analyzeSelectionSet(
+    fragment.selectionSet,
+    targetType,
+    ctx.schema,
+    ctx.fragments,
+    ctx.fieldComplexities,
+    ctx.variables,
+    ctx.defaultCost,
+    currentDepth,
+    visitedFragments
+  );
+}
+function resolveFieldArguments(field2, variables) {
+  const args = {};
+  if (!field2.arguments) {
+    return args;
+  }
+  for (const arg of field2.arguments) {
+    const value = arg.value;
+    switch (value.kind) {
+      case graphql.Kind.VARIABLE:
+        args[arg.name.value] = variables[value.name.value];
+        break;
+      case graphql.Kind.INT:
+        args[arg.name.value] = parseInt(value.value, 10);
+        break;
+      case graphql.Kind.FLOAT:
+        args[arg.name.value] = parseFloat(value.value);
+        break;
+      case graphql.Kind.STRING:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.BOOLEAN:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.NULL:
+        args[arg.name.value] = null;
+        break;
+      case graphql.Kind.ENUM:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.LIST:
+        args[arg.name.value] = [];
+        break;
+      case graphql.Kind.OBJECT:
+        args[arg.name.value] = {};
+        break;
+    }
+  }
+  return args;
+}
+var validateComplexity = (query2, operationName, variables, schema, fieldComplexities, config) => effect.Effect.gen(function* () {
+  const document = yield* effect.Effect.try({
+    try: () => graphql.parse(query2),
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to parse query: ${error}`,
+      cause: error
+    })
+  });
+  const operation = yield* effect.Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+      );
+      if (operations.length === 0) {
+        throw new Error("No operation found in query");
+      }
+      if (operationName) {
+        const op = operations.find((o) => o.name?.value === operationName);
+        if (!op) {
+          throw new Error(`Operation "${operationName}" not found`);
+        }
+        return op;
+      }
+      if (operations.length > 1) {
+        throw new Error("Multiple operations found - operationName required");
+      }
+      return operations[0];
+    },
+    catch: (error) => new ComplexityAnalysisError({
+      message: String(error),
+      cause: error
+    })
+  });
+  const calculator = config.calculator ?? defaultComplexityCalculator(config.defaultFieldComplexity ?? 1);
+  const result = yield* calculator({
+    document,
+    operation,
+    variables,
+    schema,
+    fieldComplexities
+  });
+  const checkLimit = (limitType, limit, actual) => effect.Effect.gen(function* () {
+    if (limit !== void 0 && actual > limit) {
+      const exceededInfo = {
+        result,
+        exceededLimit: limitType,
+        limit,
+        actual,
+        query: query2,
+        operationName
+      };
+      if (config.onExceeded) {
+        yield* config.onExceeded(exceededInfo);
+      }
+      yield* effect.Effect.fail(
+        new ComplexityLimitExceededError({
+          message: `Query ${limitType} of ${actual} exceeds maximum allowed ${limitType} of ${limit}`,
+          limit,
+          actual,
+          limitType
+        })
+      );
+    }
+  });
+  yield* checkLimit("depth", config.maxDepth, result.depth);
+  yield* checkLimit("complexity", config.maxComplexity, result.complexity);
+  yield* checkLimit("aliases", config.maxAliases, result.aliasCount);
+  yield* checkLimit("fields", config.maxFields, result.fieldCount);
+  return result;
+});
+var ComplexityConfigFromEnv = effect.Config.all({
+  maxDepth: effect.Config.number("GRAPHQL_MAX_DEPTH").pipe(effect.Config.option),
+  maxComplexity: effect.Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(effect.Config.option),
+  maxAliases: effect.Config.number("GRAPHQL_MAX_ALIASES").pipe(effect.Config.option),
+  maxFields: effect.Config.number("GRAPHQL_MAX_FIELDS").pipe(effect.Config.option),
+  defaultFieldComplexity: effect.Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    effect.Config.withDefault(1)
+  )
+}).pipe(
+  effect.Config.map(({ maxDepth, maxComplexity, maxAliases, maxFields, defaultFieldComplexity }) => ({
+    maxDepth: effect.Option.getOrUndefined(maxDepth),
+    maxComplexity: effect.Option.getOrUndefined(maxComplexity),
+    maxAliases: effect.Option.getOrUndefined(maxAliases),
+    maxFields: effect.Option.getOrUndefined(maxFields),
+    defaultFieldComplexity
+  }))
+);
+var depthOnlyCalculator = (info) => effect.Effect.try({
+  try: () => {
+    const fragments = /* @__PURE__ */ new Map();
+    for (const definition of info.document.definitions) {
+      if (definition.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+        fragments.set(definition.name.value, definition);
+      }
+    }
+    const depth = calculateMaxDepth(info.operation.selectionSet, fragments, 1, /* @__PURE__ */ new Set());
+    return {
+      depth,
+      complexity: 0,
+      fieldCount: 0,
+      aliasCount: 0
+    };
+  },
+  catch: (error) => new ComplexityAnalysisError({
+    message: `Failed to analyze query depth: ${error}`,
+    cause: error
+  })
+});
+function calculateMaxDepth(selectionSet, fragments, currentDepth, visitedFragments) {
+  let maxDepth = currentDepth;
+  for (const selection of selectionSet.selections) {
+    switch (selection.kind) {
+      case graphql.Kind.FIELD:
+        if (selection.selectionSet) {
+          const nestedDepth = calculateMaxDepth(
+            selection.selectionSet,
+            fragments,
+            currentDepth + 1,
+            visitedFragments
+          );
+          maxDepth = Math.max(maxDepth, nestedDepth);
+        }
+        break;
+      case graphql.Kind.FRAGMENT_SPREAD: {
+        const fragmentName = selection.name.value;
+        if (!visitedFragments.has(fragmentName)) {
+          const fragment = fragments.get(fragmentName);
+          if (fragment) {
+            const newVisited = new Set(visitedFragments);
+            newVisited.add(fragmentName);
+            const fragmentDepth = calculateMaxDepth(
+              fragment.selectionSet,
+              fragments,
+              currentDepth,
+              newVisited
+            );
+            maxDepth = Math.max(maxDepth, fragmentDepth);
+          }
+        }
+        break;
+      }
+      case graphql.Kind.INLINE_FRAGMENT: {
+        const inlineDepth = calculateMaxDepth(
+          selection.selectionSet,
+          fragments,
+          currentDepth,
+          visitedFragments
+        );
+        maxDepth = Math.max(maxDepth, inlineDepth);
+        break;
+      }
+    }
+  }
+  return maxDepth;
+}
+var combineCalculators = (...calculators) => {
+  return (info) => effect.Effect.gen(function* () {
+    let maxDepth = 0;
+    let maxComplexity = 0;
+    let maxFieldCount = 0;
+    let maxAliasCount = 0;
+    for (const calculator of calculators) {
+      const result = yield* calculator(info);
+      maxDepth = Math.max(maxDepth, result.depth);
+      maxComplexity = Math.max(maxComplexity, result.complexity);
+      maxFieldCount = Math.max(maxFieldCount, result.fieldCount);
+      maxAliasCount = Math.max(maxAliasCount, result.aliasCount);
+    }
+    return {
+      depth: maxDepth,
+      complexity: maxComplexity,
+      fieldCount: maxFieldCount,
+      aliasCount: maxAliasCount
+    };
+  });
+};
+var computeCachePolicy = (info) => effect.Effect.sync(() => {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of info.document.definitions) {
+    if (definition.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+      fragments.set(definition.name.value, definition);
+    }
+  }
+  const rootType = getRootType2(info.schema, info.operation.operation);
+  if (!rootType) {
+    return { maxAge: 0, scope: "PUBLIC" };
+  }
+  const defaultMaxAge = info.config.defaultMaxAge ?? 0;
+  const defaultScope = info.config.defaultScope ?? "PUBLIC";
+  const result = analyzeSelectionSet2(
+    info.operation.selectionSet,
+    rootType,
+    info.schema,
+    fragments,
+    info.cacheHints,
+    defaultMaxAge,
+    defaultScope,
+    void 0,
+    // No parent maxAge for root
+    /* @__PURE__ */ new Set()
+  );
+  return result;
+});
+var computeCachePolicyFromQuery = (query2, operationName, schema, cacheHints, config = {}) => effect.Effect.gen(function* () {
+  const document = yield* effect.Effect.try({
+    try: () => graphql.parse(query2),
+    catch: (error) => new Error(`Failed to parse query: ${error}`)
+  });
+  const operation = yield* effect.Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+      );
+      if (operations.length === 0) {
+        throw new Error("No operation found in query");
+      }
+      if (operationName) {
+        const op = operations.find((o) => o.name?.value === operationName);
+        if (!op) {
+          throw new Error(`Operation "${operationName}" not found`);
+        }
+        return op;
+      }
+      if (operations.length > 1) {
+        throw new Error("Multiple operations found - operationName required");
+      }
+      return operations[0];
+    },
+    catch: (error) => error
+  });
+  return yield* computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config
+  });
+});
+var toCacheControlHeader = (policy) => {
+  if (policy.maxAge === 0) {
+    return "no-store";
+  }
+  const directives = [];
+  directives.push(policy.scope === "PRIVATE" ? "private" : "public");
+  directives.push(`max-age=${policy.maxAge}`);
+  return directives.join(", ");
+};
+function getRootType2(schema, operation) {
+  switch (operation) {
+    case "query":
+      return schema.getQueryType() ?? null;
+    case "mutation":
+      return schema.getMutationType() ?? null;
+    case "subscription":
+      return schema.getSubscriptionType() ?? null;
+  }
+}
+function getNamedType2(type) {
+  if (type instanceof graphql.GraphQLNonNull || type instanceof graphql.GraphQLList) {
+    return getNamedType2(type.ofType);
+  }
+  if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLScalarType || type instanceof graphql.GraphQLEnumType) {
+    return type;
+  }
+  return null;
+}
+function isLeafType(type) {
+  const namedType = getNamedType2(type);
+  return namedType instanceof graphql.GraphQLScalarType || namedType instanceof graphql.GraphQLEnumType;
+}
+function aggregatePolicy(acc, policy) {
+  if (acc.minMaxAge === void 0) {
+    acc.minMaxAge = policy.maxAge;
+  } else {
+    acc.minMaxAge = Math.min(acc.minMaxAge, policy.maxAge);
+  }
+  if (policy.scope === "PRIVATE") {
+    acc.hasPrivate = true;
+  }
+}
+function analyzeFragmentSpread2(fragmentName, ctx, parentMaxAge, visitedFragments) {
+  if (visitedFragments.has(fragmentName)) {
+    return void 0;
+  }
+  const fragment = ctx.fragments.get(fragmentName);
+  if (!fragment) {
+    return void 0;
+  }
+  const fragmentType = ctx.schema.getType(fragment.typeCondition.name.value);
+  if (!(fragmentType instanceof graphql.GraphQLObjectType)) {
+    return void 0;
+  }
+  const newVisited = new Set(visitedFragments);
+  newVisited.add(fragmentName);
+  return analyzeSelectionSet2(fragment.selectionSet, fragmentType, ctx, parentMaxAge, newVisited);
+}
+function analyzeInlineFragment2(selection, parentType, ctx, parentMaxAge, visitedFragments) {
+  let targetType = parentType;
+  if (selection.typeCondition) {
+    const conditionType = ctx.schema.getType(selection.typeCondition.name.value);
+    if (conditionType instanceof graphql.GraphQLObjectType) {
+      targetType = conditionType;
+    }
+  }
+  return analyzeSelectionSet2(
+    selection.selectionSet,
+    targetType,
+    ctx,
+    parentMaxAge,
+    visitedFragments
+  );
+}
+function lookupEffectiveCacheHint(parentTypeName, fieldName, returnType, cacheHints) {
+  const fieldKey = `${parentTypeName}.${fieldName}`;
+  const fieldHint = cacheHints.get(fieldKey);
+  if (fieldHint) return fieldHint;
+  const namedType = getNamedType2(returnType);
+  return namedType ? cacheHints.get(namedType.name) : void 0;
+}
+function computeFieldMaxAge(hint, fieldType, parentMaxAge, defaultMaxAge) {
+  if (hint) {
+    if (hint.inheritMaxAge && parentMaxAge !== void 0) {
+      return parentMaxAge;
+    }
+    if (hint.maxAge !== void 0) {
+      return hint.maxAge;
+    }
+  }
+  if (isLeafType(fieldType) && parentMaxAge !== void 0) {
+    return parentMaxAge;
+  }
+  return defaultMaxAge;
+}
+function analyzeSelectionSet2(selectionSet, parentType, schemaOrCtx, fragmentsOrParentMaxAge, cacheHintsOrVisited, defaultMaxAge, defaultScope, parentMaxAge, visitedFragments) {
+  let ctx;
+  let actualParentMaxAge;
+  let actualVisitedFragments;
+  if (schemaOrCtx instanceof graphql.GraphQLSchema) {
+    ctx = {
+      schema: schemaOrCtx,
+      fragments: fragmentsOrParentMaxAge,
+      cacheHints: cacheHintsOrVisited,
+      defaultMaxAge,
+      defaultScope
+    };
+    actualParentMaxAge = parentMaxAge;
+    actualVisitedFragments = visitedFragments;
+  } else {
+    ctx = schemaOrCtx;
+    actualParentMaxAge = fragmentsOrParentMaxAge;
+    actualVisitedFragments = cacheHintsOrVisited;
+  }
+  const acc = { minMaxAge: void 0, hasPrivate: false };
+  for (const selection of selectionSet.selections) {
+    let fieldPolicy;
+    switch (selection.kind) {
+      case graphql.Kind.FIELD:
+        fieldPolicy = analyzeField2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case graphql.Kind.FRAGMENT_SPREAD:
+        fieldPolicy = analyzeFragmentSpread2(
+          selection.name.value,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case graphql.Kind.INLINE_FRAGMENT:
+        fieldPolicy = analyzeInlineFragment2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+    }
+    if (fieldPolicy) {
+      aggregatePolicy(acc, fieldPolicy);
+    }
+  }
+  return {
+    maxAge: acc.minMaxAge ?? ctx.defaultMaxAge,
+    scope: acc.hasPrivate ? "PRIVATE" : ctx.defaultScope
+  };
+}
+function analyzeField2(field2, parentType, ctx, parentMaxAge, visitedFragments) {
+  const fieldName = field2.name.value;
+  if (fieldName.startsWith("__")) {
+    return { maxAge: Infinity, scope: "PUBLIC" };
+  }
+  const schemaField = parentType.getFields()[fieldName];
+  if (!schemaField) {
+    return { maxAge: ctx.defaultMaxAge, scope: ctx.defaultScope };
+  }
+  const effectiveHint = lookupEffectiveCacheHint(
+    parentType.name,
+    fieldName,
+    schemaField.type,
+    ctx.cacheHints
+  );
+  const fieldMaxAge = computeFieldMaxAge(
+    effectiveHint,
+    schemaField.type,
+    parentMaxAge,
+    ctx.defaultMaxAge
+  );
+  const fieldScope = effectiveHint?.scope ?? ctx.defaultScope;
+  const namedType = getNamedType2(schemaField.type);
+  if (field2.selectionSet && namedType instanceof graphql.GraphQLObjectType) {
+    const nestedPolicy = analyzeSelectionSet2(
+      field2.selectionSet,
+      namedType,
+      ctx,
+      fieldMaxAge,
+      visitedFragments
+    );
+    return {
+      maxAge: Math.min(fieldMaxAge, nestedPolicy.maxAge),
+      scope: fieldScope === "PRIVATE" || nestedPolicy.scope === "PRIVATE" ? "PRIVATE" : "PUBLIC"
+    };
+  }
+  return { maxAge: fieldMaxAge, scope: fieldScope };
+}
+var CacheControlConfigFromEnv = effect.Config.all({
+  enabled: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(effect.Config.withDefault(true)),
+  defaultMaxAge: effect.Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(effect.Config.withDefault(0)),
+  defaultScope: effect.Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    effect.Config.withDefault("PUBLIC"),
+    effect.Config.map((s) => s === "PRIVATE" ? "PRIVATE" : "PUBLIC")
+  ),
+  calculateHttpHeaders: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_HTTP_HEADERS").pipe(
+    effect.Config.withDefault(true)
+  )
+});
+
+// src/server/router.ts
+var defaultErrorHandler = (cause) => (process.env.NODE_ENV !== "production" ? effect.Effect.logError("GraphQL error", cause) : effect.Effect.void).pipe(
+  effect.Effect.andThen(
+    platform.HttpServerResponse.json(
+      {
+        errors: [
+          {
+            message: "An error occurred processing your request"
+          }
+        ]
+      },
+      { status: 500 }
+    ).pipe(effect.Effect.orDie)
+  )
+);
+var parseGraphQLQuery = (query2, extensionsService) => effect.Effect.gen(function* () {
+  try {
+    const document = graphql.parse(query2);
+    return { ok: true, document };
+  } catch (parseError) {
+    const extensionData = yield* extensionsService.get();
+    const response = yield* platform.HttpServerResponse.json({
+      errors: [{ message: String(parseError) }],
+      extensions: Object.keys(extensionData).length > 0 ? extensionData : void 0
+    }).pipe(effect.Effect.orDie);
+    return { ok: false, response };
+  }
+});
+var runComplexityValidation = (body, schema, fieldComplexities, complexityConfig) => {
+  if (!complexityConfig) {
+    return effect.Effect.void;
+  }
+  return validateComplexity(
+    body.query,
+    body.operationName,
+    body.variables,
+    schema,
+    fieldComplexities,
+    complexityConfig
+  ).pipe(
+    effect.Effect.catchTag("ComplexityLimitExceededError", (error) => effect.Effect.fail(error)),
+    effect.Effect.catchTag(
+      "ComplexityAnalysisError",
+      (error) => effect.Effect.logWarning("Complexity analysis failed", error)
+    )
+  );
+};
+var executeGraphQLQuery = (schema, document, variables, operationName, runtime) => effect.Effect.gen(function* () {
+  const executeResult = yield* effect.Effect.try({
+    try: () => graphql.execute({
+      schema,
+      document,
+      variableValues: variables,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  if (executeResult && typeof executeResult === "object" && "then" in executeResult) {
+    return yield* effect.Effect.promise(
+      () => executeResult
+    );
+  }
+  return executeResult;
+});
+var computeCacheControlHeader = (document, operationName, schema, cacheHints, cacheControlConfig) => effect.Effect.gen(function* () {
+  if (cacheControlConfig?.enabled === false || cacheControlConfig?.calculateHttpHeaders === false) {
+    return void 0;
+  }
+  const operations = document.definitions.filter(
+    (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+  );
+  const operation = operationName ? operations.find((o) => o.name?.value === operationName) : operations[0];
+  if (!operation || operation.operation === "mutation") {
+    return void 0;
+  }
+  const cachePolicy = yield* computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config: cacheControlConfig ?? {}
+  });
+  return toCacheControlHeader(cachePolicy);
+});
+var buildGraphQLResponse = (result, extensionData, cacheControlHeader) => {
+  const finalResult = Object.keys(extensionData).length > 0 ? {
+    ...result,
+    extensions: {
+      ...result.extensions,
+      ...extensionData
+    }
+  } : result;
+  const responseHeaders = cacheControlHeader ? { "cache-control": cacheControlHeader } : void 0;
+  return platform.HttpServerResponse.json(finalResult, { headers: responseHeaders }).pipe(effect.Effect.orDie);
+};
+var handleComplexityError = (error) => platform.HttpServerResponse.json(
+  {
+    errors: [
+      {
+        message: error.message,
+        extensions: {
+          code: "COMPLEXITY_LIMIT_EXCEEDED",
+          limitType: error.limitType,
+          limit: error.limit,
+          actual: error.actual
+        }
+      }
+    ]
+  },
+  { status: 400 }
+).pipe(effect.Effect.orDie);
+var makeGraphQLRouter = (schema, layer, options = {}) => {
+  const resolvedConfig = normalizeConfig(options);
+  const fieldComplexities = options.fieldComplexities ?? /* @__PURE__ */ new Map();
+  const cacheHints = options.cacheHints ?? /* @__PURE__ */ new Map();
+  const extensions = options.extensions ?? [];
+  const errorHandler = options.errorHandler ?? defaultErrorHandler;
+  const graphqlHandler = effect.Effect.gen(function* () {
+    const extensionsService = yield* makeExtensionsService();
+    const runtime = yield* effect.Effect.runtime();
+    const request = yield* platform.HttpServerRequest.HttpServerRequest;
+    const body = yield* request.json;
+    const parseResult = yield* parseGraphQLQuery(body.query, extensionsService);
+    if (!parseResult.ok) {
+      return parseResult.response;
+    }
+    const document = parseResult.document;
+    yield* runParseHooks(extensions, body.query, document).pipe(
+      effect.Effect.provideService(ExtensionsService, extensionsService)
+    );
+    const validationRules = resolvedConfig.introspection ? void 0 : [...graphql.specifiedRules, graphql.NoSchemaIntrospectionCustomRule];
+    const validationErrors = graphql.validate(schema, document, validationRules);
+    yield* runValidateHooks(extensions, document, validationErrors).pipe(
+      effect.Effect.provideService(ExtensionsService, extensionsService)
+    );
+    if (validationErrors.length > 0) {
+      const extensionData2 = yield* extensionsService.get();
+      return yield* platform.HttpServerResponse.json(
+        {
+          errors: validationErrors.map((e) => ({
+            message: e.message,
+            locations: e.locations,
+            path: e.path
+          })),
+          extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+        },
+        { status: 400 }
+      );
+    }
+    yield* runComplexityValidation(body, schema, fieldComplexities, resolvedConfig.complexity);
+    yield* runExecuteStartHooks(extensions, {
+      source: body.query,
+      document,
+      variableValues: body.variables,
+      operationName: body.operationName,
+      schema,
+      fieldComplexities
+    }).pipe(effect.Effect.provideService(ExtensionsService, extensionsService));
+    const result = yield* executeGraphQLQuery(
+      schema,
+      document,
+      body.variables,
+      body.operationName,
+      runtime
+    );
+    yield* runExecuteEndHooks(extensions, result).pipe(
+      effect.Effect.provideService(ExtensionsService, extensionsService)
+    );
+    const extensionData = yield* extensionsService.get();
+    const cacheControlHeader = yield* computeCacheControlHeader(
+      document,
+      body.operationName,
+      schema,
+      cacheHints,
+      resolvedConfig.cacheControl
+    );
+    return yield* buildGraphQLResponse(result, extensionData, cacheControlHeader);
+  }).pipe(
+    effect.Effect.provide(layer),
+    effect.Effect.catchAll((error) => {
+      if (error instanceof ComplexityLimitExceededError) {
+        return handleComplexityError(error);
+      }
+      return effect.Effect.fail(error);
+    }),
+    effect.Effect.catchAllCause(errorHandler)
+  );
+  let router = platform.HttpRouter.empty.pipe(
+    platform.HttpRouter.post(resolvedConfig.path, graphqlHandler)
+  );
+  if (resolvedConfig.graphiql) {
+    const { path, endpoint } = resolvedConfig.graphiql;
+    router = router.pipe(
+      platform.HttpRouter.get(path, platform.HttpServerResponse.html(graphiqlHtml(endpoint)))
+    );
+  }
+  return router;
+};
+
+// src/server/schema-builder-extensions.ts
+var toRouter = (builder, layer, options) => {
+  const schema = builder.buildSchema();
+  const fieldComplexities = builder.getFieldComplexities();
+  const cacheHints = builder.getCacheHints();
+  return makeGraphQLRouter(schema, layer, { ...options, fieldComplexities, cacheHints });
+};
+var WebSocketError = class extends effect.Data.TaggedError("WebSocketError") {
+};
+var createConnectionContext = (extra) => ({
+  runtime: extra.runtime,
+  connectionParams: extra.connectionParams,
+  socket: extra.socket
+});
+var makeOnConnectHandler = (options) => {
+  if (!options?.onConnect) return void 0;
+  return async (ctx) => {
+    const extra = ctx.extra;
+    try {
+      const result = await effect.Runtime.runPromise(extra.runtime)(
+        options.onConnect(ctx.connectionParams ?? {})
+      );
+      if (typeof result === "object" && result !== null) {
+        Object.assign(extra.connectionParams, result);
+      }
+      return result !== false;
+    } catch {
+      return false;
+    }
+  };
+};
+var makeOnDisconnectHandler = (options) => {
+  if (!options?.onDisconnect) return void 0;
+  return async (ctx) => {
+    const extra = ctx.extra;
+    await effect.Runtime.runPromise(extra.runtime)(
+      options.onDisconnect(createConnectionContext(extra))
+    ).catch(() => {
+    });
+  };
+};
+var makeOnSubscribeHandler = (options, schema, complexityConfig, fieldComplexities) => {
+  return async (ctx, id, payload) => {
+    const extra = ctx.extra;
+    const connectionCtx = createConnectionContext(extra);
+    if (complexityConfig) {
+      const validationEffect = validateComplexity(
+        payload.query,
+        payload.operationName ?? void 0,
+        payload.variables ?? void 0,
+        schema,
+        fieldComplexities,
+        complexityConfig
+      ).pipe(
+        effect.Effect.catchAll((error) => {
+          if (error._tag === "ComplexityLimitExceededError") {
+            throw new graphql.GraphQLError(error.message, {
+              extensions: {
+                code: "COMPLEXITY_LIMIT_EXCEEDED",
+                limitType: error.limitType,
+                limit: error.limit,
+                actual: error.actual
+              }
+            });
+          }
+          return effect.Effect.logWarning("Complexity analysis failed for subscription", error);
+        })
+      );
+      await effect.Effect.runPromise(validationEffect);
+    }
+    if (options?.onSubscribe) {
+      await effect.Runtime.runPromise(extra.runtime)(
+        options.onSubscribe(connectionCtx, {
+          id,
+          payload: {
+            query: payload.query,
+            variables: payload.variables ?? void 0,
+            operationName: payload.operationName ?? void 0,
+            extensions: payload.extensions ?? void 0
+          }
+        })
+      );
+    }
+  };
+};
+var makeOnCompleteHandler = (options) => {
+  if (!options?.onComplete) return void 0;
+  return async (ctx, id, _payload) => {
+    const extra = ctx.extra;
+    await effect.Runtime.runPromise(extra.runtime)(
+      options.onComplete(createConnectionContext(extra), { id })
+    ).catch(() => {
+    });
+  };
+};
+var makeOnErrorHandler = (options) => {
+  if (!options?.onError) return void 0;
+  return async (ctx, _id, _payload, errors) => {
+    const extra = ctx.extra;
+    await effect.Runtime.runPromise(extra.runtime)(
+      options.onError(createConnectionContext(extra), errors)
+    ).catch(() => {
+    });
+  };
+};
+var createGraphqlWsSocketAdapter = (socket, runtime) => {
+  let messageCallback = null;
+  return {
+    adapter: {
+      protocol: socket.protocol,
+      send: (data) => effect.Runtime.runPromise(runtime)(
+        socket.send(data).pipe(effect.Effect.catchAll((error) => effect.Effect.logError("WebSocket send error", error)))
+      ),
+      close: (code, reason) => {
+        effect.Runtime.runPromise(runtime)(socket.close(code, reason)).catch(() => {
+        });
+      },
+      onMessage: (cb) => {
+        messageCallback = cb;
+      },
+      onPong: (_payload) => {
+      }
+    },
+    dispatchMessage: async (message) => {
+      if (messageCallback) {
+        await messageCallback(message);
+      }
+    }
+  };
+};
+var runConnectionLifecycle = (socket, wsServer, extra) => effect.Effect.gen(function* () {
+  const messageQueue = yield* effect.Queue.unbounded();
+  const closedDeferred = yield* effect.Deferred.make();
+  const messageFiber = yield* effect.Effect.fork(
+    effect.Stream.runForEach(socket.messages, (msg) => effect.Queue.offer(messageQueue, msg)).pipe(
+      effect.Effect.catchAll((error) => effect.Deferred.fail(closedDeferred, error))
+    )
+  );
+  const closeFiber = yield* effect.Effect.fork(
+    socket.closed.pipe(
+      effect.Effect.tap((event) => effect.Deferred.succeed(closedDeferred, event)),
+      effect.Effect.catchAll((error) => effect.Deferred.fail(closedDeferred, error))
+    )
+  );
+  const { adapter, dispatchMessage } = createGraphqlWsSocketAdapter(socket, extra.runtime);
+  const closedHandler = wsServer.opened(adapter, extra);
+  const processMessagesFiber = yield* effect.Effect.fork(
+    effect.Effect.gen(function* () {
+      while (true) {
+        const message = yield* effect.Queue.take(messageQueue);
+        yield* effect.Effect.tryPromise({
+          try: () => dispatchMessage(message),
+          catch: (error) => error
+        }).pipe(effect.Effect.catchAll(() => effect.Effect.void));
+      }
+    })
+  );
+  yield* effect.Deferred.await(closedDeferred).pipe(
+    effect.Effect.catchAll(() => effect.Effect.succeed({ code: 1e3, reason: "Error" }))
+  );
+  closedHandler(1e3, "Connection closed");
+  yield* effect.Fiber.interrupt(messageFiber);
+  yield* effect.Fiber.interrupt(closeFiber);
+  yield* effect.Fiber.interrupt(processMessagesFiber);
+  yield* effect.Queue.shutdown(messageQueue);
+}).pipe(
+  effect.Effect.catchAllCause(() => effect.Effect.void),
+  effect.Effect.scoped
+);
+var makeGraphQLWSHandler = (schema, layer, options) => {
+  const complexityConfig = options?.complexity;
+  const fieldComplexities = options?.fieldComplexities ?? /* @__PURE__ */ new Map();
+  const serverOptions = {
+    schema,
+    context: async (ctx) => {
+      const extra = ctx.extra;
+      return {
+        runtime: extra.runtime,
+        ...extra.connectionParams
+      };
+    },
+    subscribe: async (args) => graphql.subscribe(args),
+    onConnect: makeOnConnectHandler(options),
+    onDisconnect: makeOnDisconnectHandler(options),
+    onSubscribe: makeOnSubscribeHandler(options, schema, complexityConfig, fieldComplexities),
+    onComplete: makeOnCompleteHandler(options),
+    onError: makeOnErrorHandler(options)
+  };
+  const wsServer = graphqlWs.makeServer(serverOptions);
+  return (socket) => effect.Effect.gen(function* () {
+    const runtime = yield* effect.Effect.provide(effect.Effect.runtime(), layer);
+    const extra = {
+      socket,
+      runtime,
+      connectionParams: {}
+    };
+    yield* runConnectionLifecycle(socket, wsServer, extra);
+  }).pipe(
+    effect.Effect.catchAllCause(() => effect.Effect.void),
+    effect.Effect.scoped
+  );
+};
+var WS_CLOSED = 3;
+var toEffectWebSocketFromWs = (ws) => {
+  const messagesEffect = effect.Effect.gen(function* () {
+    const queue = yield* effect.Queue.unbounded();
+    const closed = yield* effect.Deferred.make();
+    ws.on("message", (data) => {
+      const message = data.toString();
+      effect.Effect.runPromise(effect.Queue.offer(queue, message)).catch(() => {
+      });
+    });
+    ws.on("error", (error) => {
+      effect.Effect.runPromise(effect.Deferred.fail(closed, new WebSocketError({ cause: error }))).catch(() => {
+      });
+    });
+    ws.on("close", (code, reason) => {
+      effect.Effect.runPromise(
+        effect.Queue.shutdown(queue).pipe(
+          effect.Effect.andThen(effect.Deferred.succeed(closed, { code, reason: reason.toString() }))
+        )
+      ).catch(() => {
+      });
+    });
+    return { queue, closed };
+  });
+  const messages = effect.Stream.unwrap(
+    messagesEffect.pipe(
+      effect.Effect.map(({ queue }) => effect.Stream.fromQueue(queue).pipe(effect.Stream.catchAll(() => effect.Stream.empty)))
+    )
+  );
+  return {
+    protocol: ws.protocol || "graphql-transport-ws",
+    send: (data) => effect.Effect.async((resume) => {
+      ws.send(data, (error) => {
+        if (error) {
+          resume(effect.Effect.fail(new WebSocketError({ cause: error })));
+        } else {
+          resume(effect.Effect.succeed(void 0));
+        }
+      });
+    }),
+    close: (code, reason) => effect.Effect.sync(() => {
+      ws.close(code ?? 1e3, reason ?? "");
+    }),
+    messages,
+    closed: effect.Effect.async((resume) => {
+      if (ws.readyState === WS_CLOSED) {
+        resume(effect.Effect.succeed({ code: 1e3, reason: "" }));
+        return;
+      }
+      const onClose = (code, reason) => {
+        cleanup();
+        resume(effect.Effect.succeed({ code, reason: reason.toString() }));
+      };
+      const onError = (error) => {
+        cleanup();
+        resume(effect.Effect.fail(new WebSocketError({ cause: error })));
+      };
+      const cleanup = () => {
+        ws.removeListener("close", onClose);
+        ws.removeListener("error", onError);
+      };
+      ws.on("close", onClose);
+      ws.on("error", onError);
+      return effect.Effect.sync(cleanup);
+    })
+  };
+};
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable nginx buffering
+};
+var SSEError = class extends effect.Data.TaggedError("SSEError") {
+};
+var formatNextEvent = (result) => ({
+  event: "next",
+  data: JSON.stringify(result)
+});
+var formatErrorEvent = (errors) => ({
+  event: "error",
+  data: JSON.stringify({ errors })
+});
+var formatCompleteEvent = () => ({
+  event: "complete",
+  data: ""
+});
+var formatSSEMessage = (event) => {
+  const lines = [`event: ${event.event}`];
+  if (event.data) {
+    lines.push(`data: ${event.data}`);
+  }
+  lines.push("", "");
+  return lines.join("\n");
+};
+var makeSSESubscriptionStream = (schema, layer, request, headers, options) => {
+  const complexityConfig = options?.complexity;
+  const fieldComplexities = options?.fieldComplexities ?? /* @__PURE__ */ new Map();
+  return effect.Stream.unwrap(
+    effect.Effect.gen(function* () {
+      const runtime = yield* effect.Effect.provide(effect.Effect.runtime(), layer);
+      let connectionContext = {};
+      if (options?.onConnect) {
+        try {
+          connectionContext = yield* effect.Effect.provide(options.onConnect(request, headers), layer);
+        } catch {
+          return effect.Stream.make(
+            formatErrorEvent([
+              new graphql.GraphQLError("Subscription connection rejected", {
+                extensions: { code: "CONNECTION_REJECTED" }
+              })
+            ]),
+            formatCompleteEvent()
+          );
+        }
+      }
+      let document;
+      try {
+        document = graphql.parse(request.query);
+      } catch (syntaxError) {
+        return effect.Stream.make(formatErrorEvent([syntaxError]), formatCompleteEvent());
+      }
+      const validationErrors = graphql.validate(schema, document);
+      if (validationErrors.length > 0) {
+        return effect.Stream.make(formatErrorEvent(validationErrors), formatCompleteEvent());
+      }
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+      );
+      const operation = request.operationName ? operations.find((o) => o.name?.value === request.operationName) : operations[0];
+      if (!operation) {
+        return effect.Stream.make(
+          formatErrorEvent([new graphql.GraphQLError("No operation found in query")]),
+          formatCompleteEvent()
+        );
+      }
+      if (operation.operation !== "subscription") {
+        return effect.Stream.make(
+          formatErrorEvent([
+            new graphql.GraphQLError(
+              `SSE endpoint only supports subscriptions, received: ${operation.operation}`,
+              { extensions: { code: "OPERATION_NOT_SUPPORTED" } }
+            )
+          ]),
+          formatCompleteEvent()
+        );
+      }
+      if (complexityConfig) {
+        const complexityResult = yield* validateComplexity(
+          request.query,
+          request.operationName,
+          request.variables,
+          schema,
+          fieldComplexities,
+          complexityConfig
+        ).pipe(
+          effect.Effect.map(() => null),
+          effect.Effect.catchAll((error) => {
+            if (error._tag === "ComplexityLimitExceededError") {
+              return effect.Effect.succeed(
+                new graphql.GraphQLError(error.message, {
+                  extensions: {
+                    code: "COMPLEXITY_LIMIT_EXCEEDED",
+                    limitType: error.limitType,
+                    limit: error.limit,
+                    actual: error.actual
+                  }
+                })
+              );
+            }
+            return effect.Effect.logWarning("Complexity analysis failed for SSE subscription", error).pipe(
+              effect.Effect.map(() => null)
+            );
+          })
+        );
+        if (complexityResult) {
+          return effect.Stream.make(formatErrorEvent([complexityResult]), formatCompleteEvent());
+        }
+      }
+      const ctx = {
+        runtime,
+        request,
+        connectionContext
+      };
+      if (options?.onSubscribe) {
+        yield* effect.Effect.provide(options.onSubscribe(ctx), layer).pipe(
+          effect.Effect.catchAll(() => effect.Effect.void)
+        );
+      }
+      const graphqlContext = {
+        runtime,
+        ...connectionContext
+      };
+      const subscriptionResult = yield* effect.Effect.tryPromise({
+        try: () => graphql.subscribe({
+          schema,
+          document,
+          variableValues: request.variables,
+          operationName: request.operationName ?? void 0,
+          contextValue: graphqlContext
+        }),
+        catch: (error) => new SSEError({ cause: error })
+      });
+      if (!isAsyncIterable(subscriptionResult)) {
+        const result = subscriptionResult;
+        if (result.errors) {
+          return effect.Stream.make(formatErrorEvent(result.errors), formatCompleteEvent());
+        }
+        return effect.Stream.make(formatNextEvent(result), formatCompleteEvent());
+      }
+      const asyncIterator = subscriptionResult[Symbol.asyncIterator]();
+      const eventStream = effect.Stream.async((emit) => {
+        let done = false;
+        const iterate = async () => {
+          try {
+            while (!done) {
+              const result = await asyncIterator.next();
+              if (result.done) {
+                emit.end();
+                break;
+              }
+              emit.single(formatNextEvent(result.value));
+            }
+          } catch (error) {
+            if (!done) {
+              emit.single(
+                formatErrorEvent([
+                  error instanceof graphql.GraphQLError ? error : new graphql.GraphQLError(
+                    error instanceof Error ? error.message : "Subscription error",
+                    { extensions: { code: "SUBSCRIPTION_ERROR" } }
+                  )
+                ])
+              );
+              emit.end();
+            }
+          }
+        };
+        iterate();
+        return effect.Effect.sync(() => {
+          done = true;
+          asyncIterator.return?.();
+        });
+      });
+      return eventStream.pipe(
+        effect.Stream.onDone(
+          () => effect.Effect.gen(function* () {
+            yield* effect.Effect.sync(() => {
+            });
+          }).pipe(effect.Effect.asVoid)
+        ),
+        effect.Stream.concat(effect.Stream.make(formatCompleteEvent())),
+        effect.Stream.onDone(() => {
+          if (options?.onComplete) {
+            return effect.Effect.provide(options.onComplete(ctx), layer).pipe(
+              effect.Effect.catchAll(() => effect.Effect.void)
+            );
+          }
+          return effect.Effect.void;
+        })
+      );
+    }).pipe(
+      effect.Effect.catchAll(
+        (error) => effect.Effect.succeed(
+          effect.Stream.make(
+            formatErrorEvent([
+              new graphql.GraphQLError(error instanceof Error ? error.message : "Internal error", {
+                extensions: { code: "INTERNAL_ERROR" }
+              })
+            ]),
+            formatCompleteEvent()
+          )
+        )
+      )
+    )
+  );
+};
+var makeGraphQLSSEHandler = (schema, layer, options) => {
+  return (request, headers) => makeSSESubscriptionStream(schema, layer, request, headers, options);
+};
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+var createAnalyzerExtension = (config = {}) => {
+  const {
+    includeComplexity = true,
+    includeDepth = true,
+    includeFieldCount = false,
+    includeAliasCount = false,
+    key = "analyzer",
+    thresholds,
+    defaultFieldComplexity = 1,
+    fieldComplexities: configFieldComplexities
+  } = config;
+  return {
+    name: "analyzer",
+    description: "Reports query complexity metrics in response extensions",
+    onExecuteStart: (args) => effect.Effect.gen(function* () {
+      const ext = yield* ExtensionsService;
+      const operation = findOperation(args);
+      if (!operation) {
+        return;
+      }
+      const fieldComplexities = configFieldComplexities ?? args.fieldComplexities;
+      const calculator = defaultComplexityCalculator(defaultFieldComplexity);
+      const result = yield* calculator({
+        document: args.document,
+        operation,
+        variables: args.variableValues,
+        schema: args.schema,
+        fieldComplexities
+      }).pipe(
+        effect.Effect.catchAll(
+          (error) => effect.Effect.logWarning("Analyzer extension: complexity calculation failed", error).pipe(
+            effect.Effect.as(null)
+          )
+        )
+      );
+      if (!result) {
+        return;
+      }
+      yield* checkThresholds(result, thresholds);
+      const output = {};
+      if (includeComplexity) {
+        output.complexity = result.complexity;
+      }
+      if (includeDepth) {
+        output.depth = result.depth;
+      }
+      if (includeFieldCount) {
+        output.fieldCount = result.fieldCount;
+      }
+      if (includeAliasCount) {
+        output.aliasCount = result.aliasCount;
+      }
+      yield* ext.set(key, output);
+    })
+  };
+};
+function findOperation(args) {
+  const operations = args.document.definitions.filter(
+    (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+  );
+  if (operations.length === 0) {
+    return null;
+  }
+  if (args.operationName) {
+    return operations.find((o) => o.name?.value === args.operationName) ?? null;
+  }
+  return operations[0];
+}
+function checkThresholds(result, thresholds) {
+  if (!thresholds) {
+    return effect.Effect.void;
+  }
+  const warnings = [];
+  if (thresholds.depth !== void 0 && result.depth > thresholds.depth) {
+    warnings.push(`Query depth ${result.depth} exceeds threshold ${thresholds.depth}`);
+  }
+  if (thresholds.complexity !== void 0 && result.complexity > thresholds.complexity) {
+    warnings.push(
+      `Query complexity ${result.complexity} exceeds threshold ${thresholds.complexity}`
+    );
+  }
+  if (thresholds.fieldCount !== void 0 && result.fieldCount > thresholds.fieldCount) {
+    warnings.push(
+      `Query field count ${result.fieldCount} exceeds threshold ${thresholds.fieldCount}`
+    );
+  }
+  if (thresholds.aliasCount !== void 0 && result.aliasCount > thresholds.aliasCount) {
+    warnings.push(
+      `Query alias count ${result.aliasCount} exceeds threshold ${thresholds.aliasCount}`
+    );
+  }
+  if (warnings.length > 0) {
+    return effect.Effect.logWarning("Analyzer extension: thresholds exceeded", {
+      warnings,
+      result
+    });
+  }
+  return effect.Effect.void;
+}
+
+Object.defineProperty(exports, "DirectiveLocation", {
+  enumerable: true,
+  get: function () { return graphql.DirectiveLocation; }
+});
+Object.defineProperty(exports, "GraphQLBoolean", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLBoolean; }
+});
+Object.defineProperty(exports, "GraphQLEnumType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLEnumType; }
+});
+Object.defineProperty(exports, "GraphQLFloat", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLFloat; }
+});
+Object.defineProperty(exports, "GraphQLID", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLID; }
+});
+Object.defineProperty(exports, "GraphQLInputObjectType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLInputObjectType; }
+});
+Object.defineProperty(exports, "GraphQLInt", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLInt; }
+});
+Object.defineProperty(exports, "GraphQLInterfaceType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLInterfaceType; }
+});
+Object.defineProperty(exports, "GraphQLList", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLList; }
+});
+Object.defineProperty(exports, "GraphQLNonNull", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLNonNull; }
+});
+Object.defineProperty(exports, "GraphQLObjectType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLObjectType; }
+});
+Object.defineProperty(exports, "GraphQLScalarType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLScalarType; }
+});
+Object.defineProperty(exports, "GraphQLSchema", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLSchema; }
+});
+Object.defineProperty(exports, "GraphQLString", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLString; }
+});
+Object.defineProperty(exports, "GraphQLUnionType", {
+  enumerable: true,
+  get: function () { return graphql.GraphQLUnionType; }
+});
+Object.defineProperty(exports, "Kind", {
+  enumerable: true,
+  get: function () { return graphql.Kind; }
+});
+Object.defineProperty(exports, "graphql", {
+  enumerable: true,
+  get: function () { return graphql.graphql; }
+});
+Object.defineProperty(exports, "lexicographicSortSchema", {
+  enumerable: true,
+  get: function () { return graphql.lexicographicSortSchema; }
+});
+Object.defineProperty(exports, "printSchema", {
+  enumerable: true,
+  get: function () { return graphql.printSchema; }
+});
+exports.AuthorizationError = AuthorizationError;
+exports.CacheControlConfigFromEnv = CacheControlConfigFromEnv;
+exports.ComplexityAnalysisError = ComplexityAnalysisError;
+exports.ComplexityConfigFromEnv = ComplexityConfigFromEnv;
+exports.ComplexityLimitExceededError = ComplexityLimitExceededError;
+exports.ExtensionsService = ExtensionsService;
+exports.GraphQLError = GraphQLError2;
+exports.GraphQLRequestContext = GraphQLRequestContext;
+exports.GraphQLRouterConfigFromEnv = GraphQLRouterConfigFromEnv;
+exports.GraphQLSchemaBuilder = GraphQLSchemaBuilder;
+exports.Loader = Loader;
+exports.MissingResolverContextError = MissingResolverContextError;
+exports.NotFoundError = NotFoundError;
+exports.ResolverContext = ResolverContext;
+exports.ResolverContextStore = ResolverContextStore;
+exports.SSEError = SSEError;
+exports.SSE_HEADERS = SSE_HEADERS;
+exports.ValidationError = ValidationError;
+exports.WS_CLOSED = WS_CLOSED;
+exports.WebSocketError = WebSocketError;
+exports.combineCalculators = combineCalculators;
+exports.compose = compose;
+exports.computeCachePolicy = computeCachePolicy;
+exports.computeCachePolicyFromQuery = computeCachePolicyFromQuery;
+exports.createAnalyzerExtension = createAnalyzerExtension;
+exports.defaultComplexityCalculator = defaultComplexityCalculator;
+exports.defaultConfig = defaultConfig;
+exports.defaultErrorHandler = defaultErrorHandler;
+exports.depthOnlyCalculator = depthOnlyCalculator;
+exports.directive = directive;
+exports.enumType = enumType;
+exports.execute = execute;
+exports.extension = extension;
+exports.field = field;
+exports.formatCompleteEvent = formatCompleteEvent;
+exports.formatErrorEvent = formatErrorEvent;
+exports.formatNextEvent = formatNextEvent;
+exports.formatSSEMessage = formatSSEMessage;
+exports.get = get;
+exports.getOption = getOption;
+exports.getOrElse = getOrElse;
+exports.getSchemaName = getSchemaName;
+exports.graphiqlHtml = graphiqlHtml;
+exports.has = has;
+exports.inputType = inputType;
+exports.interfaceType = interfaceType;
+exports.make = make3;
+exports.makeExtensionsService = makeExtensionsService;
+exports.makeGraphQLRouter = makeGraphQLRouter;
+exports.makeGraphQLSSEHandler = makeGraphQLSSEHandler;
+exports.makeGraphQLWSHandler = makeGraphQLWSHandler;
+exports.makeRequestContextLayer = makeRequestContextLayer;
+exports.makeSSESubscriptionStream = makeSSESubscriptionStream;
+exports.makeStoreLayer = makeStoreLayer;
+exports.middleware = middleware;
+exports.mutation = mutation;
+exports.normalizeConfig = normalizeConfig;
+exports.objectType = objectType;
+exports.query = query;
+exports.runExecuteEndHooks = runExecuteEndHooks;
+exports.runExecuteStartHooks = runExecuteStartHooks;
+exports.runParseHooks = runParseHooks;
+exports.runValidateHooks = runValidateHooks;
+exports.scoped = scoped;
+exports.set = set;
+exports.setMany = setMany;
+exports.storeLayer = storeLayer;
+exports.subscription = subscription;
+exports.toCacheControlHeader = toCacheControlHeader;
+exports.toEffectWebSocketFromWs = toEffectWebSocketFromWs;
+exports.toGraphQLArgs = toGraphQLArgs;
+exports.toGraphQLInputType = toGraphQLInputType;
+exports.toGraphQLObjectType = toGraphQLObjectType;
+exports.toGraphQLType = toGraphQLType;
+exports.toRouter = toRouter;
+exports.unionType = unionType;
+exports.validateComplexity = validateComplexity;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map