@effect-gql/core 0.1.0 → 1.1.0

package/index.js

@@ -0,0 +1,3292 @@
+import { GraphQLDirective, GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLUnionType, GraphQLSchema, GraphQLNonNull, GraphQLString, GraphQLFloat, GraphQLBoolean, GraphQLInt, GraphQLList, parse, GraphQLError, validate, execute as execute$1, Kind, specifiedRules, NoSchemaIntrospectionCustomRule, subscribe, GraphQLScalarType } from 'graphql';
+export { DirectiveLocation, GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, Kind, graphql, lexicographicSortSchema, printSchema } from 'graphql';
+import { Pipeable, Context, Data, Layer, Effect, Ref, HashMap, Config, Option, Schema, Runtime, Queue, Stream, Fiber, Deferred } from 'effect';
+import * as S2 from 'effect/Schema';
+import * as AST from 'effect/SchemaAST';
+import DataLoader from 'dataloader';
+import { HttpIncomingMessage, HttpServerResponse, HttpServerRequest, HttpRouter } from '@effect/platform';
+import { makeServer } from 'graphql-ws';
+
+// src/builder/index.ts
+var isIntegerType = (ast) => {
+  if (ast._tag === "Refinement") {
+    const refinement = ast;
+    const annotations = refinement.annotations;
+    if (annotations) {
+      const identifier = AST.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 GraphQLString;
+  if (ast._tag === "NumberKeyword") return GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return GraphQLInt;
+    }
+    return toGraphQLType(S2.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? GraphQLInt : GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2.make(elements[0].type);
+      return new GraphQLList(toGraphQLType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Object_${Math.random().toString(36).slice(2, 11)}`;
+    return new GraphQLObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLType(S2.make(ast.to));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLType(S2.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLType(S2.make(innerAst));
+  }
+  return GraphQLString;
+};
+var toGraphQLInputType = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "StringKeyword") return GraphQLString;
+  if (ast._tag === "NumberKeyword") return GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return GraphQLInt;
+    }
+    return toGraphQLInputType(S2.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? GraphQLInt : GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2.make(elements[0].type);
+      return new GraphQLList(toGraphQLInputType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Input_${Math.random().toString(36).slice(2, 11)}`;
+    return new GraphQLInputObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLInputType(S2.make(ast.from));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLInputType(S2.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLInputType(S2.make(innerAst));
+  }
+  return 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.make(field2.type);
+      let fieldType = toGraphQLType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new 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 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.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new 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.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 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.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.make(toAst.rest[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new GraphQLList(elementType);
+    } else if (toAst.elements.length > 0) {
+      const elementSchema = S2.make(toAst.elements[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new GraphQLList(elementType);
+    }
+  }
+  return toGraphQLTypeWithRegistry(S2.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.make(ast.types[0]), ctx);
+  }
+  return toGraphQLType(S2.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.make(ast.rest[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new GraphQLList(elementType);
+  } else if (ast.elements && ast.elements.length > 0) {
+    const elementSchema = S2.make(ast.elements[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new GraphQLList(elementType);
+  }
+  return toGraphQLType(S2.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.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.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.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.make(nonUndefinedTypes[0]),
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+    }
+    if (nonUndefinedTypes.length === 1 && nonUndefinedTypes[0]._tag === "TypeLiteral") {
+      return toGraphQLInputTypeWithRegistry(
+        S2.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.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.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 = applyDirectives(
+        config.resolve(args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent: _parent, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    }
+  };
+  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 = applyDirectives(
+        config.resolve(parent, args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    }
+  };
+  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 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 = config.resolve(value, args);
+      const middlewareContext = { parent: value, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    } : (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 Runtime.runPromise(runtime)(Queue.unbounded());
+    fiber = Runtime.runFork(runtime)(
+      Effect.ensuring(
+        Stream.runForEach(stream, (value) => Queue.offer(queue, Option.some(value))),
+        // Signal completion by pushing None
+        Queue.offer(queue, Option.none())
+      )
+    );
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      await initialize();
+      if (done) {
+        return { done: true, value: void 0 };
+      }
+      try {
+        const optionValue = await Runtime.runPromise(runtime)(Queue.take(queue));
+        if (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 Runtime.runPromise(runtime)(
+            Fiber.interrupt(fiber)
+          );
+          await Runtime.runPromise(runtime)(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 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,
+      description,
+      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,
+      description,
+      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 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 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 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 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 GraphQLObjectType({
+        name: typeName,
+        description: typeReg.description,
+        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 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 GraphQLObjectType({
+        name: "Query",
+        fields: registries.queryFields
+      });
+    }
+    if (Object.keys(registries.mutationFields).length > 0) {
+      schemaConfig.mutation = new GraphQLObjectType({
+        name: "Mutation",
+        fields: registries.mutationFields
+      });
+    }
+    if (Object.keys(registries.subscriptionFields).length > 0) {
+      schemaConfig.subscription = new GraphQLObjectType({
+        name: "Subscription",
+        fields: registries.subscriptionFields
+      });
+    }
+    return new 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 = 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.gen(function* () {
+  const ref = yield* Ref.make({});
+  return ExtensionsService.of({
+    set: (key, value) => Ref.update(ref, (current) => ({ ...current, [key]: value })),
+    merge: (key, value) => 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: () => Ref.get(ref)
+  });
+});
+var runExtensionHooks = (extensions, hookName, getHookEffect) => Effect.forEach(
+  extensions.filter((ext) => ext[hookName] !== void 0),
+  (ext) => getHookEffect(ext).pipe(
+    Effect.catchAllCause(
+      (cause) => 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.gen(function* () {
+  const extensionsService = yield* makeExtensionsService();
+  const runtime = yield* Effect.runtime();
+  let document;
+  try {
+    document = parse(source);
+  } catch (parseError) {
+    const extensionData2 = yield* extensionsService.get();
+    return {
+      errors: [
+        parseError instanceof GraphQLError ? parseError : new GraphQLError(String(parseError))
+      ],
+      extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+    };
+  }
+  yield* runParseHooks(extensions, source, document).pipe(
+    Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const validationErrors = validate(schema, document);
+  yield* runValidateHooks(extensions, document, validationErrors).pipe(
+    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.provideService(ExtensionsService, extensionsService)
+  );
+  const executeResult = yield* Effect.try({
+    try: () => execute$1({
+      schema,
+      document,
+      variableValues,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  const resolvedResult = executeResult && typeof executeResult === "object" && "then" in executeResult ? yield* Effect.promise(() => executeResult) : executeResult;
+  yield* runExecuteEndHooks(extensions, resolvedResult).pipe(
+    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.provide(layer));
+var GraphQLError2 = class extends Data.TaggedError("GraphQLError") {
+};
+var ValidationError = class extends Data.TaggedError("ValidationError") {
+};
+var AuthorizationError = class extends Data.TaggedError("AuthorizationError") {
+};
+var NotFoundError = class extends Data.TaggedError("NotFoundError") {
+};
+var GraphQLRequestContext = Context.GenericTag("GraphQLRequestContext");
+var makeRequestContextLayer = (context) => 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 = 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 Layer.effect(
+      this.Service,
+      Effect.gen(function* () {
+        const instances = {};
+        for (const name of Object.keys(self.definitions)) {
+          const def = self.definitions[name];
+          instances[name] = yield* createDataLoader(def);
+        }
+        return instances;
+      })
+    );
+  }
+  /**
+   * Helper to use loaders in a resolver with a callback.
+   */
+  use(fn) {
+    const self = this;
+    return Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      return yield* Effect.promise(() => fn(loaders));
+    });
+  }
+  /**
+   * Load a single value by key.
+   * This is the most common operation in resolvers.
+   *
+   * @internal The internal cast is safe because LoaderInstances<Defs> guarantees
+   * that loaders[name] is a DataLoader with the correct key/value types.
+   */
+  load(name, key) {
+    const self = this;
+    return Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      const loader = loaders[name];
+      return yield* Effect.promise(() => loader.load(key));
+    });
+  }
+  /**
+   * Load multiple values by keys.
+   * All keys are batched into a single request.
+   *
+   * @internal The internal cast is safe because LoaderInstances<Defs> guarantees
+   * that loaders[name] is a DataLoader with the correct key/value types.
+   */
+  loadMany(name, keys) {
+    const self = this;
+    return Effect.gen(function* () {
+      const loaders = yield* self.Service;
+      const loader = loaders[name];
+      const results = yield* Effect.promise(() => loader.loadMany(keys));
+      for (const result of results) {
+        if (result instanceof Error) {
+          return yield* Effect.fail(result);
+        }
+      }
+      return results;
+    });
+  }
+};
+function createSingleDataLoader(def, context) {
+  return new DataLoader(async (keys) => {
+    const items = await Effect.runPromise(def.batch(keys).pipe(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;
+    });
+  });
+}
+function createGroupedDataLoader(def, context) {
+  return new DataLoader(async (keys) => {
+    const items = await Effect.runPromise(def.batch(keys).pipe(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) ?? []);
+  });
+}
+function createDataLoader(def) {
+  return Effect.gen(function* () {
+    const context = yield* Effect.context();
+    if (def._tag === "single") {
+      return createSingleDataLoader(def, context);
+    } else {
+      return createGroupedDataLoader(def, context);
+    }
+  });
+}
+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 = Context.GenericTag(
+  "effect-gql/ResolverContextStore"
+);
+var makeStoreLayer = () => Effect.map(
+  Ref.make(HashMap.empty()),
+  (ref) => Layer.succeed(ResolverContextStore, { ref })
+);
+var storeLayer = Layer.effect(
+  ResolverContextStore,
+  Effect.map(Ref.make(HashMap.empty()), (ref) => ({ ref }))
+);
+var make3 = (name) => ({
+  _tag: "ResolverContextSlot",
+  name,
+  _A: void 0
+});
+var get = (slot) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Effect.flatMap(Ref.get(store.ref), (map) => {
+    const value = HashMap.get(map, slot.name);
+    return Option.match(value, {
+      onNone: () => Effect.fail(new MissingResolverContextError(slot.name)),
+      onSome: (v) => Effect.succeed(v)
+    });
+  })
+);
+var getOption = (slot) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Effect.map(Ref.get(store.ref), (map) => HashMap.get(map, slot.name))
+);
+var set = (slot, value) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Ref.update(store.ref, (map) => HashMap.set(map, slot.name, value))
+);
+var setMany = (values) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Ref.update(store.ref, (map) => {
+    let result = map;
+    for (const [slot, value] of values) {
+      result = HashMap.set(result, slot.name, value);
+    }
+    return result;
+  })
+);
+var has = (slot) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Effect.map(Ref.get(store.ref), (map) => HashMap.has(map, slot.name))
+);
+var getOrElse = (slot, orElse) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Effect.map(
+    Ref.get(store.ref),
+    (map) => Option.getOrElse(HashMap.get(map, slot.name), orElse)
+  )
+);
+var scoped = (slot, value) => (effect) => Effect.flatMap(
+  ResolverContextStore,
+  (store) => Effect.acquireUseRelease(
+    // Acquire: save current value and set new one
+    Effect.flatMap(Ref.get(store.ref), (map) => {
+      const previous = HashMap.get(map, slot.name);
+      return Effect.as(Ref.set(store.ref, HashMap.set(map, slot.name, value)), previous);
+    }),
+    // Use: run the effect
+    () => effect,
+    // Release: restore previous value
+    (previous) => Ref.update(
+      store.ref,
+      (map) => Option.match(previous, {
+        onNone: () => HashMap.remove(map, slot.name),
+        onSome: (v) => 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 = Config.all({
+  path: Config.string("GRAPHQL_PATH").pipe(Config.withDefault("/graphql")),
+  introspection: Config.boolean("GRAPHQL_INTROSPECTION").pipe(Config.withDefault(true)),
+  graphiqlEnabled: Config.boolean("GRAPHIQL_ENABLED").pipe(Config.withDefault(false)),
+  graphiqlPath: Config.string("GRAPHIQL_PATH").pipe(Config.withDefault("/graphiql")),
+  graphiqlEndpoint: Config.string("GRAPHIQL_ENDPOINT").pipe(Config.option),
+  maxDepth: Config.number("GRAPHQL_MAX_DEPTH").pipe(Config.option),
+  maxComplexity: Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(Config.option),
+  maxAliases: Config.number("GRAPHQL_MAX_ALIASES").pipe(Config.option),
+  maxFields: Config.number("GRAPHQL_MAX_FIELDS").pipe(Config.option),
+  defaultFieldComplexity: Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    Config.withDefault(1)
+  ),
+  cacheControlEnabled: Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(
+    Config.withDefault(false)
+  ),
+  cacheControlDefaultMaxAge: Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(
+    Config.withDefault(0)
+  ),
+  cacheControlDefaultScope: Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    Config.withDefault("PUBLIC")
+  )
+}).pipe(
+  Config.map(
+    ({
+      path,
+      introspection,
+      graphiqlEnabled,
+      graphiqlPath,
+      graphiqlEndpoint,
+      maxDepth,
+      maxComplexity,
+      maxAliases,
+      maxFields,
+      defaultFieldComplexity,
+      cacheControlEnabled,
+      cacheControlDefaultMaxAge,
+      cacheControlDefaultScope
+    }) => {
+      const hasComplexity = Option.isSome(maxDepth) || Option.isSome(maxComplexity) || Option.isSome(maxAliases) || Option.isSome(maxFields);
+      return {
+        path,
+        introspection,
+        graphiql: graphiqlEnabled ? {
+          path: graphiqlPath,
+          endpoint: Option.isSome(graphiqlEndpoint) ? graphiqlEndpoint.value : path
+        } : false,
+        complexity: hasComplexity ? {
+          maxDepth: Option.getOrUndefined(maxDepth),
+          maxComplexity: Option.getOrUndefined(maxComplexity),
+          maxAliases: Option.getOrUndefined(maxAliases),
+          maxFields: 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, subscriptionEndpoint) => `<!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)},
+        subscriptionUrl: ${JSON.stringify(subscriptionEndpoint ?? endpoint)},
+      });
+      ReactDOM.createRoot(document.getElementById('graphiql')).render(
+        React.createElement(GraphiQL, { fetcher })
+      );
+    </script>
+  </body>
+</html>`;
+var ComplexityLimitExceededError = class extends Data.TaggedError("ComplexityLimitExceededError") {
+};
+var ComplexityAnalysisError = class extends Data.TaggedError("ComplexityAnalysisError") {
+};
+var defaultComplexityCalculator = (defaultCost = 1) => {
+  return (info) => Effect.try({
+    try: () => {
+      const fragments = /* @__PURE__ */ new Map();
+      for (const definition of info.document.definitions) {
+        if (definition.kind === 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 GraphQLNonNull || type instanceof GraphQLList) {
+    return getNamedType(type.ofType);
+  }
+  if (type instanceof 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 Kind.FIELD:
+      return analyzeField(selection, parentType, ctx, currentDepth, visitedFragments);
+    case Kind.FRAGMENT_SPREAD:
+      return analyzeFragmentSpread(selection, ctx, currentDepth, visitedFragments);
+    case 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 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 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 Kind.VARIABLE:
+        args[arg.name.value] = variables[value.name.value];
+        break;
+      case Kind.INT:
+        args[arg.name.value] = parseInt(value.value, 10);
+        break;
+      case Kind.FLOAT:
+        args[arg.name.value] = parseFloat(value.value);
+        break;
+      case Kind.STRING:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.BOOLEAN:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.NULL:
+        args[arg.name.value] = null;
+        break;
+      case Kind.ENUM:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.LIST:
+        args[arg.name.value] = [];
+        break;
+      case Kind.OBJECT:
+        args[arg.name.value] = {};
+        break;
+    }
+  }
+  return args;
+}
+var validateComplexity = (query2, operationName, variables, schema, fieldComplexities, config) => Effect.gen(function* () {
+  const document = yield* Effect.try({
+    try: () => parse(query2),
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to parse query: ${error}`,
+      cause: error
+    })
+  });
+  const operation = yield* Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === 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.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.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 = Config.all({
+  maxDepth: Config.number("GRAPHQL_MAX_DEPTH").pipe(Config.option),
+  maxComplexity: Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(Config.option),
+  maxAliases: Config.number("GRAPHQL_MAX_ALIASES").pipe(Config.option),
+  maxFields: Config.number("GRAPHQL_MAX_FIELDS").pipe(Config.option),
+  defaultFieldComplexity: Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    Config.withDefault(1)
+  )
+}).pipe(
+  Config.map(({ maxDepth, maxComplexity, maxAliases, maxFields, defaultFieldComplexity }) => ({
+    maxDepth: Option.getOrUndefined(maxDepth),
+    maxComplexity: Option.getOrUndefined(maxComplexity),
+    maxAliases: Option.getOrUndefined(maxAliases),
+    maxFields: Option.getOrUndefined(maxFields),
+    defaultFieldComplexity
+  }))
+);
+var depthOnlyCalculator = (info) => Effect.try({
+  try: () => {
+    const fragments = /* @__PURE__ */ new Map();
+    for (const definition of info.document.definitions) {
+      if (definition.kind === 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 Kind.FIELD:
+        if (selection.selectionSet) {
+          const nestedDepth = calculateMaxDepth(
+            selection.selectionSet,
+            fragments,
+            currentDepth + 1,
+            visitedFragments
+          );
+          maxDepth = Math.max(maxDepth, nestedDepth);
+        }
+        break;
+      case 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 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.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.sync(() => {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of info.document.definitions) {
+    if (definition.kind === 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.gen(function* () {
+  const document = yield* Effect.try({
+    try: () => parse(query2),
+    catch: (error) => new Error(`Failed to parse query: ${error}`)
+  });
+  const operation = yield* Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === 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 GraphQLNonNull || type instanceof GraphQLList) {
+    return getNamedType2(type.ofType);
+  }
+  if (type instanceof GraphQLObjectType || type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) {
+    return type;
+  }
+  return null;
+}
+function isLeafType(type) {
+  const namedType = getNamedType2(type);
+  return namedType instanceof GraphQLScalarType || namedType instanceof 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 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 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 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 Kind.FIELD:
+        fieldPolicy = analyzeField2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case Kind.FRAGMENT_SPREAD:
+        fieldPolicy = analyzeFragmentSpread2(
+          selection.name.value,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case 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 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 = Config.all({
+  enabled: Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(Config.withDefault(true)),
+  defaultMaxAge: Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(Config.withDefault(0)),
+  defaultScope: Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    Config.withDefault("PUBLIC"),
+    Config.map((s) => s === "PRIVATE" ? "PRIVATE" : "PUBLIC")
+  ),
+  calculateHttpHeaders: Config.boolean("GRAPHQL_CACHE_CONTROL_HTTP_HEADERS").pipe(
+    Config.withDefault(true)
+  )
+});
+
+// src/server/router.ts
+var defaultErrorHandler = (cause) => (process.env.NODE_ENV !== "production" ? Effect.logError("GraphQL error", cause) : Effect.void).pipe(
+  Effect.andThen(
+    HttpServerResponse.json(
+      {
+        errors: [
+          {
+            message: "An error occurred processing your request"
+          }
+        ]
+      },
+      { status: 500 }
+    ).pipe(Effect.orDie)
+  )
+);
+var GraphQLRequestBodySchema = Schema.Struct({
+  query: Schema.String,
+  variables: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Unknown }), {
+    as: "Option"
+  }),
+  operationName: Schema.optionalWith(Schema.String, { as: "Option" })
+});
+var decodeRequestBody = HttpIncomingMessage.schemaBodyJson(GraphQLRequestBodySchema);
+var parseGraphQLQuery = (query2, extensionsService) => {
+  try {
+    const document = parse(query2);
+    return Effect.succeed({ ok: true, document });
+  } catch (parseError) {
+    return extensionsService.get().pipe(
+      Effect.flatMap(
+        (extensionData) => HttpServerResponse.json({
+          errors: [{ message: String(parseError) }],
+          extensions: Object.keys(extensionData).length > 0 ? extensionData : void 0
+        }).pipe(
+          Effect.orDie,
+          Effect.map((response) => ({ ok: false, response }))
+        )
+      )
+    );
+  }
+};
+var runComplexityValidation = (body, schema, fieldComplexities, complexityConfig) => {
+  if (!complexityConfig) {
+    return Effect.void;
+  }
+  return validateComplexity(
+    body.query,
+    body.operationName,
+    body.variables,
+    schema,
+    fieldComplexities,
+    complexityConfig
+  ).pipe(
+    Effect.catchTag("ComplexityLimitExceededError", (error) => Effect.fail(error)),
+    Effect.catchTag(
+      "ComplexityAnalysisError",
+      (error) => Effect.logWarning("Complexity analysis failed", error)
+    )
+  );
+};
+var isPromiseLike = (value) => value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+var executeGraphQLQuery = (schema, document, variables, operationName, runtime) => {
+  const tryExecute = Effect.try({
+    try: () => execute$1({
+      schema,
+      document,
+      variableValues: variables,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  return tryExecute.pipe(
+    Effect.flatMap((executeResult) => {
+      if (isPromiseLike(executeResult)) {
+        return Effect.promise(() => executeResult);
+      }
+      return Effect.succeed(executeResult);
+    })
+  );
+};
+var computeCacheControlHeader = (document, operationName, schema, cacheHints, cacheControlConfig) => {
+  if (cacheControlConfig?.enabled === false || cacheControlConfig?.calculateHttpHeaders === false) {
+    return Effect.succeed(void 0);
+  }
+  const operations = document.definitions.filter(
+    (d) => d.kind === Kind.OPERATION_DEFINITION
+  );
+  const operation = operationName ? operations.find((o) => o.name?.value === operationName) : operations[0];
+  if (!operation || operation.operation === "mutation") {
+    return Effect.succeed(void 0);
+  }
+  return computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config: cacheControlConfig ?? {}
+  }).pipe(Effect.map(toCacheControlHeader));
+};
+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 HttpServerResponse.json(finalResult, { headers: responseHeaders }).pipe(Effect.orDie);
+};
+var handleComplexityError = (error) => HttpServerResponse.json(
+  {
+    errors: [
+      {
+        message: error.message,
+        extensions: {
+          code: "COMPLEXITY_LIMIT_EXCEEDED",
+          limitType: error.limitType,
+          limit: error.limit,
+          actual: error.actual
+        }
+      }
+    ]
+  },
+  { status: 400 }
+).pipe(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.gen(function* () {
+    const extensionsService = yield* makeExtensionsService();
+    const runtime = yield* Effect.runtime();
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const parsedBody = yield* decodeRequestBody(request);
+    const body = {
+      query: parsedBody.query,
+      variables: parsedBody.variables._tag === "Some" ? parsedBody.variables.value : void 0,
+      operationName: parsedBody.operationName._tag === "Some" ? parsedBody.operationName.value : void 0
+    };
+    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.provideService(ExtensionsService, extensionsService)
+    );
+    const validationRules = resolvedConfig.introspection ? void 0 : specifiedRules.concat(NoSchemaIntrospectionCustomRule);
+    const validationErrors = validate(schema, document, validationRules);
+    yield* runValidateHooks(extensions, document, validationErrors).pipe(
+      Effect.provideService(ExtensionsService, extensionsService)
+    );
+    if (validationErrors.length > 0) {
+      const extensionData2 = yield* extensionsService.get();
+      return yield* 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.provideService(ExtensionsService, extensionsService));
+    const result = yield* executeGraphQLQuery(
+      schema,
+      document,
+      body.variables,
+      body.operationName,
+      runtime
+    );
+    yield* runExecuteEndHooks(extensions, result).pipe(
+      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.provide(layer),
+    Effect.catchAll((error) => {
+      if (error instanceof ComplexityLimitExceededError) {
+        return handleComplexityError(error);
+      }
+      return Effect.fail(error);
+    }),
+    Effect.catchAllCause(errorHandler)
+  );
+  let router = HttpRouter.empty.pipe(
+    HttpRouter.post(resolvedConfig.path, graphqlHandler)
+  );
+  if (resolvedConfig.graphiql) {
+    const { path, endpoint, subscriptionEndpoint } = resolvedConfig.graphiql;
+    router = router.pipe(
+      HttpRouter.get(
+        path,
+        HttpServerResponse.html(graphiqlHtml(endpoint, subscriptionEndpoint))
+      )
+    );
+  }
+  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 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 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 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.catchAll((error) => {
+          if (error._tag === "ComplexityLimitExceededError") {
+            throw new GraphQLError(error.message, {
+              extensions: {
+                code: "COMPLEXITY_LIMIT_EXCEEDED",
+                limitType: error.limitType,
+                limit: error.limit,
+                actual: error.actual
+              }
+            });
+          }
+          return Effect.logWarning("Complexity analysis failed for subscription", error);
+        })
+      );
+      await Effect.runPromise(validationEffect);
+    }
+    if (options?.onSubscribe) {
+      await 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 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 Runtime.runPromise(extra.runtime)(
+      options.onError(createConnectionContext(extra), errors)
+    ).catch(() => {
+    });
+  };
+};
+var createGraphqlWsSocketAdapter = (socket, runtime) => {
+  let messageCallback = null;
+  return {
+    adapter: {
+      protocol: socket.protocol,
+      send: (data) => Runtime.runPromise(runtime)(
+        socket.send(data).pipe(Effect.catchAll((error) => Effect.logError("WebSocket send error", error)))
+      ),
+      close: (code, reason) => {
+        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.gen(function* () {
+  const messageQueue = yield* Queue.unbounded();
+  const closedDeferred = yield* Deferred.make();
+  const messageFiber = yield* Effect.fork(
+    Stream.runForEach(socket.messages, (msg) => Queue.offer(messageQueue, msg)).pipe(
+      Effect.catchAll((error) => Deferred.fail(closedDeferred, error))
+    )
+  );
+  const closeFiber = yield* Effect.fork(
+    socket.closed.pipe(
+      Effect.tap((event) => Deferred.succeed(closedDeferred, event)),
+      Effect.catchAll((error) => Deferred.fail(closedDeferred, error))
+    )
+  );
+  const { adapter, dispatchMessage } = createGraphqlWsSocketAdapter(socket, extra.runtime);
+  const closedHandler = wsServer.opened(adapter, extra);
+  const processMessagesFiber = yield* Effect.fork(
+    Effect.gen(function* () {
+      while (true) {
+        const message = yield* Queue.take(messageQueue);
+        yield* Effect.tryPromise({
+          try: () => dispatchMessage(message),
+          catch: (error) => error
+        }).pipe(Effect.catchAll(() => Effect.void));
+      }
+    })
+  );
+  yield* Deferred.await(closedDeferred).pipe(
+    Effect.catchAll(() => Effect.succeed({ code: 1e3, reason: "Error" }))
+  );
+  closedHandler(1e3, "Connection closed");
+  yield* Fiber.interrupt(messageFiber);
+  yield* Fiber.interrupt(closeFiber);
+  yield* Fiber.interrupt(processMessagesFiber);
+  yield* Queue.shutdown(messageQueue);
+}).pipe(
+  Effect.catchAllCause(() => Effect.void),
+  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) => subscribe(args),
+    onConnect: makeOnConnectHandler(options),
+    onDisconnect: makeOnDisconnectHandler(options),
+    onSubscribe: makeOnSubscribeHandler(options, schema, complexityConfig, fieldComplexities),
+    onComplete: makeOnCompleteHandler(options),
+    onError: makeOnErrorHandler(options)
+  };
+  const wsServer = makeServer(serverOptions);
+  return (socket) => Effect.gen(function* () {
+    const runtime = yield* Effect.provide(Effect.runtime(), layer);
+    const extra = {
+      socket,
+      runtime,
+      connectionParams: {}
+    };
+    yield* runConnectionLifecycle(socket, wsServer, extra);
+  }).pipe(
+    Effect.catchAllCause(() => Effect.void),
+    Effect.scoped
+  );
+};
+var WS_CLOSED = 3;
+var toEffectWebSocketFromWs = (ws) => {
+  const messagesEffect = Effect.gen(function* () {
+    const queue = yield* Queue.unbounded();
+    const closed = yield* Deferred.make();
+    ws.on("message", (data) => {
+      const message = data.toString();
+      Effect.runPromise(Queue.offer(queue, message)).catch(() => {
+      });
+    });
+    ws.on("error", (error) => {
+      Effect.runPromise(Deferred.fail(closed, new WebSocketError({ cause: error }))).catch(() => {
+      });
+    });
+    ws.on("close", (code, reason) => {
+      Effect.runPromise(
+        Queue.shutdown(queue).pipe(
+          Effect.andThen(Deferred.succeed(closed, { code, reason: reason.toString() }))
+        )
+      ).catch(() => {
+      });
+    });
+    return { queue, closed };
+  });
+  const messages = Stream.unwrap(
+    messagesEffect.pipe(
+      Effect.map(({ queue }) => Stream.fromQueue(queue).pipe(Stream.catchAll(() => Stream.empty)))
+    )
+  );
+  return {
+    protocol: ws.protocol || "graphql-transport-ws",
+    send: (data) => Effect.async((resume) => {
+      ws.send(data, (error) => {
+        if (error) {
+          resume(Effect.fail(new WebSocketError({ cause: error })));
+        } else {
+          resume(Effect.succeed(void 0));
+        }
+      });
+    }),
+    close: (code, reason) => Effect.sync(() => {
+      ws.close(code ?? 1e3, reason ?? "");
+    }),
+    messages,
+    closed: Effect.async((resume) => {
+      if (ws.readyState === WS_CLOSED) {
+        resume(Effect.succeed({ code: 1e3, reason: "" }));
+        return;
+      }
+      const onClose = (code, reason) => {
+        cleanup();
+        resume(Effect.succeed({ code, reason: reason.toString() }));
+      };
+      const onError = (error) => {
+        cleanup();
+        resume(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.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 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 Stream.unwrap(
+    Effect.gen(function* () {
+      const runtime = yield* Effect.provide(Effect.runtime(), layer);
+      let connectionContext = {};
+      if (options?.onConnect) {
+        try {
+          connectionContext = yield* Effect.provide(options.onConnect(request, headers), layer);
+        } catch {
+          return Stream.make(
+            formatErrorEvent([
+              new GraphQLError("Subscription connection rejected", {
+                extensions: { code: "CONNECTION_REJECTED" }
+              })
+            ]),
+            formatCompleteEvent()
+          );
+        }
+      }
+      let document;
+      try {
+        document = parse(request.query);
+      } catch (syntaxError) {
+        return Stream.make(formatErrorEvent([syntaxError]), formatCompleteEvent());
+      }
+      const validationErrors = validate(schema, document);
+      if (validationErrors.length > 0) {
+        return Stream.make(formatErrorEvent(validationErrors), formatCompleteEvent());
+      }
+      const operations = document.definitions.filter(
+        (d) => d.kind === Kind.OPERATION_DEFINITION
+      );
+      const operation = request.operationName ? operations.find((o) => o.name?.value === request.operationName) : operations[0];
+      if (!operation) {
+        return Stream.make(
+          formatErrorEvent([new GraphQLError("No operation found in query")]),
+          formatCompleteEvent()
+        );
+      }
+      if (operation.operation !== "subscription") {
+        return Stream.make(
+          formatErrorEvent([
+            new 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.map(() => null),
+          Effect.catchAll((error) => {
+            if (error._tag === "ComplexityLimitExceededError") {
+              return Effect.succeed(
+                new GraphQLError(error.message, {
+                  extensions: {
+                    code: "COMPLEXITY_LIMIT_EXCEEDED",
+                    limitType: error.limitType,
+                    limit: error.limit,
+                    actual: error.actual
+                  }
+                })
+              );
+            }
+            return Effect.logWarning("Complexity analysis failed for SSE subscription", error).pipe(
+              Effect.map(() => null)
+            );
+          })
+        );
+        if (complexityResult) {
+          return Stream.make(formatErrorEvent([complexityResult]), formatCompleteEvent());
+        }
+      }
+      const ctx = {
+        runtime,
+        request,
+        connectionContext
+      };
+      if (options?.onSubscribe) {
+        yield* Effect.provide(options.onSubscribe(ctx), layer).pipe(
+          Effect.catchAll(() => Effect.void)
+        );
+      }
+      const graphqlContext = {
+        runtime,
+        ...connectionContext
+      };
+      const subscriptionResult = yield* Effect.tryPromise({
+        try: () => 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 Stream.make(formatErrorEvent(result.errors), formatCompleteEvent());
+        }
+        return Stream.make(formatNextEvent(result), formatCompleteEvent());
+      }
+      const asyncIterator = subscriptionResult[Symbol.asyncIterator]();
+      const eventStream = 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 GraphQLError ? error : new GraphQLError(
+                    error instanceof Error ? error.message : "Subscription error",
+                    { extensions: { code: "SUBSCRIPTION_ERROR" } }
+                  )
+                ])
+              );
+              emit.end();
+            }
+          }
+        };
+        iterate();
+        return Effect.sync(() => {
+          done = true;
+          asyncIterator.return?.();
+        });
+      });
+      return eventStream.pipe(
+        Stream.onDone(
+          () => Effect.gen(function* () {
+            yield* Effect.sync(() => {
+            });
+          }).pipe(Effect.asVoid)
+        ),
+        Stream.concat(Stream.make(formatCompleteEvent())),
+        Stream.onDone(() => {
+          if (options?.onComplete) {
+            return Effect.provide(options.onComplete(ctx), layer).pipe(
+              Effect.catchAll(() => Effect.void)
+            );
+          }
+          return Effect.void;
+        })
+      );
+    }).pipe(
+      Effect.catchAll(
+        (error) => Effect.succeed(
+          Stream.make(
+            formatErrorEvent([
+              new 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.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.catchAll(
+          (error) => Effect.logWarning("Analyzer extension: complexity calculation failed", error).pipe(
+            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 === 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.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.logWarning("Analyzer extension: thresholds exceeded", {
+      warnings,
+      result
+    });
+  }
+  return Effect.void;
+}
+
+export { AuthorizationError, CacheControlConfigFromEnv, ComplexityAnalysisError, ComplexityConfigFromEnv, ComplexityLimitExceededError, ExtensionsService, GraphQLError2 as GraphQLError, GraphQLRequestContext, GraphQLRouterConfigFromEnv, GraphQLSchemaBuilder, Loader, MissingResolverContextError, NotFoundError, ResolverContext, ResolverContextStore, SSEError, SSE_HEADERS, ValidationError, WS_CLOSED, WebSocketError, combineCalculators, compose, computeCachePolicy, computeCachePolicyFromQuery, createAnalyzerExtension, defaultComplexityCalculator, defaultConfig, defaultErrorHandler, depthOnlyCalculator, directive, enumType, execute, extension, field, formatCompleteEvent, formatErrorEvent, formatNextEvent, formatSSEMessage, get, getOption, getOrElse, getSchemaName, graphiqlHtml, has, inputType, interfaceType, make3 as make, makeExtensionsService, makeGraphQLRouter, makeGraphQLSSEHandler, makeGraphQLWSHandler, makeRequestContextLayer, makeSSESubscriptionStream, makeStoreLayer, middleware, mutation, normalizeConfig, objectType, query, runExecuteEndHooks, runExecuteStartHooks, runParseHooks, runValidateHooks, scoped, set, setMany, storeLayer, subscription, toCacheControlHeader, toEffectWebSocketFromWs, toGraphQLArgs, toGraphQLInputType, toGraphQLObjectType, toGraphQLType, toRouter, unionType, validateComplexity };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map