@soda-gql/core 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -1,13 +1,59 @@
-const require_slice = require('./slice-C-FIQK-f.cjs');
-const require_merge = require('./merge-ZxKV1syS.cjs');
+const require_schema = require('./schema-DuWaRhdp.cjs');
 let graphql = require("graphql");
 
+//#region packages/core/src/types/type-foundation/var-ref.ts
+var VarRef = class {
+	constructor(inner) {
+		this.inner = inner;
+	}
+	static getInner(varRef) {
+		return varRef.inner;
+	}
+};
+const isVarRef = (value) => {
+	return typeof value === "object" && value !== null && value instanceof VarRef;
+};
+const createVarRefFromVariable = (name) => {
+	return new VarRef({
+		type: "variable",
+		name
+	});
+};
+const createVarRefFromConstValue = (value) => {
+	return new VarRef({
+		type: "const-value",
+		value
+	});
+};
+const getVarRefInner = (varRef) => {
+	return VarRef.getInner(varRef);
+};
+/**
+* Get the variable name from a VarRef.
+* Throws if the VarRef contains a const-value instead of a variable reference.
+*/
+const getVarRefName = (varRef) => {
+	const inner = VarRef.getInner(varRef);
+	if (inner.type !== "variable") throw new Error("Expected variable reference, got const-value");
+	return inner.name;
+};
+/**
+* Get the const value from a VarRef.
+* Throws if the VarRef contains a variable reference instead of a const-value.
+*/
+const getVarRefValue = (varRef) => {
+	const inner = VarRef.getInner(varRef);
+	if (inner.type !== "const-value") throw new Error("Expected const-value, got variable reference");
+	return inner.value;
+};
+
+//#endregion
 //#region packages/core/src/composer/build-document.ts
 const buildArgumentValue = (value) => {
 	if (value === void 0) return null;
 	if (value === null) return { kind: graphql.Kind.NULL };
-	if (value instanceof require_slice.VarRef) {
-		const inner = require_slice.VarRef.getInner(value);
+	if (value instanceof VarRef) {
+		const inner = VarRef.getInner(value);
 		if (inner.type === "variable") return {
 			kind: graphql.Kind.VARIABLE,
 			name: {
@@ -236,6 +282,245 @@ const buildDocument = (options) => {
 	};
 };
 
+//#endregion
+//#region packages/core/src/composer/colocate.ts
+/**
+* Creates a $colocate helper function for fragment colocation.
+*
+* $colocate takes an object of { label: fields } and applies prefix-based
+* aliasing to each entry. This mirrors the structure of createExecutionResultParser
+* from @soda-gql/colocation-tools.
+*
+* @example
+* ```typescript
+* // In operation definition
+* query.operation({
+*   name: "GetData",
+*   fields: ({ $ }) => $colocate({
+*     userCard: userCardFragment.embed({ userId: $.userId }),
+*     posts: postsFragment.embed({ userId: $.userId }),
+*   }),
+* });
+*
+* // In parser definition (same labels)
+* createExecutionResultParser({
+*   userCard: userCardProjection,
+*   posts: postsProjection,
+* });
+* ```
+*/
+const createColocateHelper = () => {
+	/**
+	* Colocate multiple field selections with labeled prefixes.
+	*
+	* @param entries - Object mapping labels to field selections
+	* @returns Merged object of all prefixed field entries
+	*/
+	const $colocate = (entries) => Object.fromEntries(Object.entries(entries).flatMap(([label, fields]) => Object.entries(fields).map(([key, value]) => [`${label}_${key}`, value])));
+	return $colocate;
+};
+
+//#endregion
+//#region packages/core/src/composer/field-path-context.ts
+/**
+* Shared mutable container for field path context.
+* Only synchronous access is supported.
+*/
+const fieldPathContext = { current: null };
+/**
+* Get the current field path.
+* Returns null if not in a field building context.
+*
+* @example
+* ```typescript
+* import { getCurrentFieldPath } from '@soda-gql/core';
+*
+* // Inside a field builder or model embed:
+* const path = getCurrentFieldPath();
+* console.log(path?.full); // "$.user.posts[].author"
+* ```
+*/
+const getCurrentFieldPath = () => fieldPathContext.current;
+/**
+* Run a function with a specific field path context.
+* Restores the previous path after the function completes.
+*
+* @internal
+*/
+const withFieldPath = (path, fn) => {
+	const previousPath = fieldPathContext.current;
+	fieldPathContext.current = path;
+	try {
+		return fn();
+	} finally {
+		fieldPathContext.current = previousPath;
+	}
+};
+/**
+* Append a new segment to the current path.
+*
+* @internal
+*/
+const appendToPath = (parent, segment) => {
+	const listSuffix = segment.isList ? "[]" : "";
+	const newSegment = {
+		field: segment.field,
+		parent: segment.parentType,
+		isList: segment.isList
+	};
+	if (!parent) return {
+		full: `$.${segment.field}${listSuffix}`,
+		segments: [newSegment]
+	};
+	return {
+		full: `${parent.full}.${segment.field}${listSuffix}`,
+		segments: [...parent.segments, newSegment]
+	};
+};
+/**
+* Check if a type specifier represents a list type.
+* Matches patterns like "Type:![]!", "Type:![]?", "Type:?[]!", etc.
+*
+* @internal
+*/
+const isListType = (typeString) => {
+	return typeString.includes("[]");
+};
+
+//#endregion
+//#region packages/core/src/utils/map-values.ts
+function mapValues(obj, fn) {
+	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
+}
+
+//#endregion
+//#region packages/core/src/composer/fields-builder.ts
+const cacheMapBySchema = /* @__PURE__ */ new WeakMap();
+const ensureCacheMapBySchema = (schema) => {
+	const cachedCacheMap = cacheMapBySchema.get(schema);
+	if (cachedCacheMap) return cachedCacheMap;
+	const cacheMap = /* @__PURE__ */ new Map();
+	cacheMapBySchema.set(schema, cacheMap);
+	return cacheMap;
+};
+const createFieldFactories = (schema, typeName) => {
+	const cacheMap = ensureCacheMapBySchema(schema);
+	const cached = cacheMap.get(typeName);
+	if (cached) return cached;
+	const factories = createFieldFactoriesInner(schema, typeName);
+	cacheMap.set(typeName, factories);
+	return factories;
+};
+const createFieldFactoriesInner = (schema, typeName) => {
+	const typeDef = schema.object[typeName];
+	if (!typeDef) throw new Error(`Type ${typeName} is not defined in schema objects`);
+	const entries = Object.entries(typeDef.fields).map(([fieldName, type]) => {
+		const factory = (fieldArgs, extras) => {
+			const wrap = (value) => require_schema.wrapByKey(extras?.alias ?? fieldName, value);
+			if (type.kind === "object") {
+				const factoryReturn = ((nest) => {
+					const nestedFields = withFieldPath(appendToPath(getCurrentFieldPath(), {
+						field: fieldName,
+						parentType: typeName,
+						isList: isListType(type.modifier)
+					}), () => nest({ f: createFieldFactories(schema, type.name) }));
+					return wrap({
+						parent: typeName,
+						field: fieldName,
+						type,
+						args: fieldArgs ?? {},
+						directives: extras?.directives ?? {},
+						object: nestedFields,
+						union: null
+					});
+				});
+				return factoryReturn;
+			}
+			if (type.kind === "union") {
+				const factoryReturn = ((nest) => {
+					const nestedUnion = withFieldPath(appendToPath(getCurrentFieldPath(), {
+						field: fieldName,
+						parentType: typeName,
+						isList: isListType(type.modifier)
+					}), () => mapValues(nest, (builder, memberName) => {
+						if (!builder) throw new Error(`Builder is undefined for member name: ${memberName}`);
+						return builder({ f: createFieldFactories(schema, memberName) });
+					}));
+					return wrap({
+						parent: typeName,
+						field: fieldName,
+						type,
+						args: fieldArgs ?? {},
+						directives: extras?.directives ?? {},
+						object: null,
+						union: nestedUnion
+					});
+				});
+				return factoryReturn;
+			}
+			if (type.kind === "scalar" || type.kind === "enum" || type.kind === "typename") return wrap({
+				parent: typeName,
+				field: fieldName,
+				type,
+				args: fieldArgs ?? {},
+				directives: extras?.directives ?? {},
+				object: null,
+				union: null
+			});
+			throw new Error(`Unsupported field type: ${type}`);
+		};
+		return [fieldName, factory];
+	});
+	return Object.fromEntries(entries);
+};
+
+//#endregion
+//#region packages/core/src/types/element/lazy-evaluator.ts
+/**
+* Creates a lazy evaluator with caching, async support, and dependency ordering.
+*
+* @param define - Factory function that produces the value
+* @param getDeps - Optional function returning dependencies to evaluate first
+* @param createDepGenerator - Function to create evaluation generator for a dependency
+* @returns An executor generator function
+*/
+const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
+	let cache = null;
+	let promise = null;
+	return function* execute(context) {
+		if (cache) return cache.value;
+		if (promise) {
+			yield promise;
+			return cache.value;
+		}
+		if (getDeps) for (const dep of getDeps()) yield* createDepGenerator(dep);
+		const defined = define$1(context);
+		if (!(defined instanceof Promise)) return (cache = { value: defined }).value;
+		promise = defined.then((value) => {
+			cache = { value };
+			promise = null;
+		});
+		yield promise;
+		return cache.value;
+	};
+};
+/**
+* Creates an evaluation generator from an executor.
+* Wraps the executor's generator and discards its return value.
+*/
+function* createEvaluationGenerator(executor, context) {
+	yield* executor(context);
+}
+/**
+* Executes the evaluator synchronously.
+* Throws if async operation is encountered.
+*/
+const evaluateSync = (executor, context) => {
+	const result = executor(context).next();
+	if (!result.done) throw new Error("Async operation is not supported in sync evaluation.");
+	return result.value;
+};
+
 //#endregion
 //#region packages/core/src/types/element/gql-element.ts
 const GQL_ELEMENT_FACTORY = Symbol("GQL_ELEMENT_FACTORY");
@@ -244,40 +529,28 @@ var GqlElement = class GqlElement {
 	[GQL_ELEMENT_FACTORY];
 	[GQL_ELEMENT_CONTEXT] = null;
 	constructor(define$1, getDeps) {
-		let cache = null;
-		let promise = null;
-		this[GQL_ELEMENT_FACTORY] = function* execute(context) {
-			if (cache) return cache.value;
-			if (promise) {
-				yield promise;
-				return cache.value;
-			}
-			if (getDeps) for (const dep of getDeps()) yield* GqlElement.createEvaluationGenerator(dep);
-			const defined = define$1(context);
-			if (!(defined instanceof Promise)) return (cache = { value: defined }).value;
-			promise = defined.then((value) => {
-				cache = { value };
-				promise = null;
-			});
-			yield promise;
-			return cache.value;
-		};
+		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define$1, getDeps, GqlElement.createEvaluationGenerator);
 		Object.defineProperty(this, "$infer", { get() {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
 		} });
 	}
+	attach(attachment) {
+		let cache = null;
+		Object.defineProperty(this, attachment.name, { get() {
+			if (cache) return cache;
+			GqlElement.evaluateInstantly(this);
+			return cache = attachment.createValue(this);
+		} });
+		return this;
+	}
 	static setContext(element, context) {
 		element[GQL_ELEMENT_CONTEXT] = context;
 	}
-	static *createEvaluationGenerator(element) {
-		const context = element[GQL_ELEMENT_CONTEXT];
-		yield* element[GQL_ELEMENT_FACTORY](context);
+	static createEvaluationGenerator(element) {
+		return createEvaluationGenerator(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
 	}
 	static evaluateInstantly(element) {
-		const context = element[GQL_ELEMENT_CONTEXT];
-		const result = element[GQL_ELEMENT_FACTORY](context).next();
-		if (!result.done) throw new Error("Async operation is not supported in sync evaluation.");
-		return result.value;
+		return evaluateSync(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
 	}
 	static evaluateSync(element) {
 		GqlElement.evaluateInstantly(element);
@@ -288,44 +561,25 @@ var GqlElement = class GqlElement {
 };
 
 //#endregion
-//#region packages/core/src/types/element/composed-operation.ts
-var ComposedOperation = class ComposedOperation extends GqlElement {
+//#region packages/core/src/types/element/fragment.ts
+var Fragment = class Fragment extends GqlElement {
 	constructor(define$1) {
 		super(define$1);
 	}
-	get operationType() {
-		return GqlElement.get(this).operationType;
-	}
-	get operationName() {
-		return GqlElement.get(this).operationName;
-	}
-	get variableNames() {
-		return GqlElement.get(this).variableNames;
-	}
-	get projectionPathGraph() {
-		return GqlElement.get(this).projectionPathGraph;
-	}
-	get document() {
-		return GqlElement.get(this).document;
-	}
-	get parse() {
-		return GqlElement.get(this).parse;
+	get typename() {
+		return GqlElement.get(this).typename;
 	}
-	get metadata() {
-		return GqlElement.get(this).metadata;
+	get embed() {
+		return GqlElement.get(this).embed;
 	}
 	static create(define$1) {
-		return new ComposedOperation(define$1);
+		return new Fragment(define$1);
 	}
 };
 
 //#endregion
-//#region packages/core/src/types/element/fields-builder.ts
-const mergeFields = (fields) => Object.assign({}, ...fields);
-
-//#endregion
-//#region packages/core/src/types/element/inline-operation.ts
-var InlineOperation = class InlineOperation extends GqlElement {
+//#region packages/core/src/types/element/operation.ts
+var Operation = class Operation extends GqlElement {
 	constructor(define$1) {
 		super(define$1);
 	}
@@ -348,213 +602,113 @@ var InlineOperation = class InlineOperation extends GqlElement {
 		return GqlElement.get(this).metadata;
 	}
 	static create(define$1) {
-		return new InlineOperation(define$1);
+		return new Operation(define$1);
 	}
 };
 
 //#endregion
-//#region packages/core/src/types/element/model.ts
-var Model = class Model extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
-	}
-	get typename() {
-		return GqlElement.get(this).typename;
-	}
-	get fragment() {
-		return GqlElement.get(this).fragment;
-	}
-	get normalize() {
-		return GqlElement.get(this).normalize;
-	}
-	static create(define$1) {
-		return new Model(define$1);
+//#region packages/core/src/composer/fragment-usage-context.ts
+/**
+* Shared mutable container for collecting fragment usages.
+* Only synchronous access is supported.
+*/
+const fragmentUsageContext = { current: null };
+/**
+* Run a function with fragment usage collection enabled.
+* Returns both the function result and collected fragment usages.
+*
+* @internal
+*/
+const withFragmentUsageCollection = (fn) => {
+	const previousCollector = fragmentUsageContext.current;
+	const usages = [];
+	fragmentUsageContext.current = usages;
+	try {
+		return {
+			result: fn(),
+			usages
+		};
+	} finally {
+		fragmentUsageContext.current = previousCollector;
 	}
 };
-
-//#endregion
-//#region packages/core/src/types/element/slice.ts
-var Slice = class Slice extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
-	}
-	get operationType() {
-		return GqlElement.get(this).operationType;
-	}
-	get embed() {
-		return GqlElement.get(this).embed;
-	}
-	static create(define$1) {
-		return new Slice(define$1);
-	}
+/**
+* Record a fragment usage. Called when fragment.embed() is invoked.
+* No-op if not in a collection context.
+*
+* @internal
+*/
+const recordFragmentUsage = (record) => {
+	if (fragmentUsageContext.current) fragmentUsageContext.current.push(record);
 };
 
 //#endregion
-//#region packages/core/src/composer/projection-path-graph.ts
-function createPathGraph(paths) {
-	const intermediate = paths.reduce((acc, { label, raw, segments: [segment, ...segments] }) => {
-		if (segment) (acc[segment] || (acc[segment] = [])).push({
-			label,
-			raw,
-			segments
-		});
-		return acc;
-	}, {});
-	return {
-		matches: paths.map(({ label, raw, segments }) => ({
-			label,
-			path: raw,
-			exact: segments.length === 0
-		})),
-		children: require_slice.mapValues(intermediate, (paths$1) => createPathGraph(paths$1))
-	};
-}
-function createPathGraphFromSliceEntries(fragments) {
-	return createPathGraph(Object.entries(fragments).flatMap(([label, slice]) => Array.from(new Map(slice.projection.paths.map(({ full: raw, segments }) => {
-		const [first, ...rest] = segments;
-		return [raw, {
-			label,
-			raw,
-			segments: [`${label}_${first}`, ...rest]
-		}];
-	})).values())));
-}
+//#region packages/core/src/composer/input.ts
+const createVarAssignments = (definitions, providedValues) => {
+	return mapValues(definitions, (_definition, key) => {
+		const varName = key;
+		if (!providedValues || providedValues[varName] === void 0) return createVarRefFromConstValue(void 0);
+		const provided = providedValues[varName];
+		if (isVarRef(provided)) return provided;
+		return createVarRefFromConstValue(provided);
+	});
+};
+const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => createVarRefFromVariable(name));
 
 //#endregion
-//#region packages/core/src/composer/composed-operation.ts
-const createComposedOperationComposerFactory = (options = {}) => {
-	const { metadataAdapter } = options;
-	return (operationType) => {
-		return (options$1, builder) => {
-			return ComposedOperation.create(() => {
-				const { operationName } = options$1;
-				const variables = require_slice.mergeVarDefinitions(options$1.variables ?? []);
-				const $ = require_slice.createVarRefs(variables);
-				const fragments = builder({ $ });
-				const fields = Object.fromEntries(Object.entries(fragments).flatMap(([label, { getFields: fields$1 }]) => Object.entries(fields$1).map(([key, reference]) => [`${label}_${key}`, reference])));
-				const projectionPathGraph = createPathGraphFromSliceEntries(fragments);
-				const document = buildDocument({
-					operationName,
-					operationType,
-					variables,
-					fields
-				});
-				const operationMetadataResult = options$1.metadata?.({
-					$,
-					document
-				});
-				const sliceMetadataResults = Object.values(fragments).map((fragment) => fragment.metadata).filter((m) => m != null);
-				const mergeSliceMetadata = metadataAdapter?.mergeSliceMetadata ?? require_merge.defaultMergeSliceMetadata;
-				const createDefinition = (operationMetadata, sliceMetadataList) => {
-					const metadata = mergeSliceMetadata(operationMetadata ?? {}, sliceMetadataList);
-					return {
-						operationType,
-						operationName,
-						variableNames: Object.keys(variables),
-						projectionPathGraph,
-						document,
-						parse: require_slice.createExecutionResultParser({
-							fragments,
-							projectionPathGraph
-						}),
-						metadata: Object.keys(metadata).length > 0 ? metadata : void 0
-					};
-				};
-				const hasAsyncOperationMetadata = operationMetadataResult instanceof Promise;
-				const hasAsyncSliceMetadata = sliceMetadataResults.some((m) => m instanceof Promise);
-				if (hasAsyncOperationMetadata || hasAsyncSliceMetadata) return Promise.all([hasAsyncOperationMetadata ? operationMetadataResult : Promise.resolve(operationMetadataResult), Promise.all(sliceMetadataResults.map((m) => m instanceof Promise ? m : Promise.resolve(m)))]).then(([operationMetadata, sliceMetadataList]) => createDefinition(operationMetadata, sliceMetadataList));
-				return createDefinition(operationMetadataResult, sliceMetadataResults);
-			});
+//#region packages/core/src/composer/fragment.ts
+const createGqlFragmentComposers = (schema, _adapter) => {
+	const createFragmentComposer = (typename) => {
+		return (options) => {
+			const varDefinitions = options.variables ?? {};
+			const { metadata, fields } = options;
+			return Fragment.create(() => ({
+				typename,
+				embed: (variables) => {
+					const f = createFieldFactories(schema, typename);
+					const $ = createVarAssignments(varDefinitions, variables);
+					recordFragmentUsage({
+						metadataBuilder: metadata ? () => metadata({ $ }) : null,
+						path: getCurrentFieldPath()
+					});
+					return fields({
+						f,
+						$
+					});
+				}
+			}));
 		};
 	};
+	return mapValues(schema.object, (_, typename) => createFragmentComposer(typename));
 };
 
 //#endregion
-//#region packages/core/src/utils/wrap-by-key.ts
-function wrapByKey(name, value) {
-	return { [name]: value };
-}
-
-//#endregion
-//#region packages/core/src/composer/fields-builder.ts
-const cacheMapBySchema = /* @__PURE__ */ new WeakMap();
-const ensureCacheMapBySchema = (schema) => {
-	const cachedCacheMap = cacheMapBySchema.get(schema);
-	if (cachedCacheMap) return cachedCacheMap;
-	const cacheMap = /* @__PURE__ */ new Map();
-	cacheMapBySchema.set(schema, cacheMap);
-	return cacheMap;
-};
-const createFieldFactories = (schema, typeName) => {
-	const cacheMap = ensureCacheMapBySchema(schema);
-	const cached = cacheMap.get(typeName);
-	if (cached) return cached;
-	const factories = createFieldFactoriesInner(schema, typeName);
-	cacheMap.set(typeName, factories);
-	return factories;
-};
-const createFieldFactoriesInner = (schema, typeName) => {
-	const typeDef = schema.object[typeName];
-	if (!typeDef) throw new Error(`Type ${typeName} is not defined in schema objects`);
-	const entries = Object.entries(typeDef.fields).map(([fieldName, type]) => {
-		const factory = (fieldArgs, extras) => {
-			const wrap = (value) => wrapByKey(extras?.alias ?? fieldName, value);
-			if (type.kind === "object") {
-				const factoryReturn = ((nest) => wrap({
-					parent: typeName,
-					field: fieldName,
-					type,
-					args: fieldArgs ?? {},
-					directives: extras?.directives ?? {},
-					object: mergeFields(nest({ f: createFieldFactories(schema, type.name) })),
-					union: null
-				}));
-				return factoryReturn;
-			}
-			if (type.kind === "union") {
-				const factoryReturn = ((nest) => wrap({
-					parent: typeName,
-					field: fieldName,
-					type,
-					args: fieldArgs ?? {},
-					directives: extras?.directives ?? {},
-					object: null,
-					union: require_slice.mapValues(nest, (builder, memberName) => {
-						if (!builder) throw new Error(`Builder is undefined for member name: ${memberName}`);
-						return mergeFields(builder({ f: createFieldFactories(schema, memberName) }));
-					})
-				}));
-				return factoryReturn;
-			}
-			if (type.kind === "scalar" || type.kind === "enum" || type.kind === "typename") return wrap({
-				parent: typeName,
-				field: fieldName,
-				type,
-				args: fieldArgs ?? {},
-				directives: extras?.directives ?? {},
-				object: null,
-				union: null
-			});
-			throw new Error(`Unsupported field type: ${type}`);
-		};
-		return [fieldName, factory];
-	});
-	return Object.fromEntries(entries);
-};
+//#region packages/core/src/types/metadata/adapter.ts
+/**
+* Creates the default adapter instance.
+* @internal
+*/
+const createDefaultAdapter = () => ({ aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata) });
+/**
+* The default adapter instance.
+*/
+const defaultMetadataAdapter = createDefaultAdapter();
 
 //#endregion
-//#region packages/core/src/composer/inline-operation.ts
-const createInlineOperationComposerFactory = (schema) => {
+//#region packages/core/src/composer/operation.ts
+const createOperationComposerFactory = (schema, adapter) => {
+	const resolvedAdapter = adapter ?? defaultMetadataAdapter;
 	return (operationType) => {
 		const operationTypeName = schema.operations[operationType];
 		if (operationTypeName === null) throw new Error(`Operation type ${operationType} is not defined in schema roots`);
-		return (options, fieldBuilder) => {
-			return InlineOperation.create(() => {
-				const { operationName } = options;
-				const variables = require_slice.mergeVarDefinitions(options.variables ?? []);
-				const $ = require_slice.createVarRefs(variables);
-				const fields = mergeFields(fieldBuilder({
-					f: createFieldFactories(schema, operationTypeName),
+		return (options) => {
+			return Operation.create(() => {
+				const { name: operationName } = options;
+				const variables = options.variables ?? {};
+				const $ = createVarRefs(variables);
+				const f = createFieldFactories(schema, operationTypeName);
+				const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => options.fields({
+					f,
 					$
 				}));
 				const document = buildDocument({
@@ -563,10 +717,6 @@ const createInlineOperationComposerFactory = (schema) => {
 					variables,
 					fields
 				});
-				const metadataResult = options.metadata?.({
-					$,
-					document
-				});
 				const createDefinition = (metadata) => ({
 					operationType,
 					operationName,
@@ -575,133 +725,85 @@ const createInlineOperationComposerFactory = (schema) => {
 					document,
 					metadata
 				});
-				if (metadataResult instanceof Promise) return metadataResult.then(createDefinition);
-				return createDefinition(metadataResult);
+				if (!fragmentUsages.some((u) => u.metadataBuilder) && !options.metadata) return createDefinition(void 0);
+				const fragmentMetadataResults = fragmentUsages.map((usage) => usage.metadataBuilder ? usage.metadataBuilder() : void 0);
+				const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => r instanceof Promise);
+				const buildOperationMetadata = (resolvedFragmentMetadata) => {
+					const fragmentMetaInfos = fragmentUsages.map((usage, index) => ({
+						metadata: resolvedFragmentMetadata[index],
+						fieldPath: usage.path
+					}));
+					const aggregatedFragmentMetadata = resolvedAdapter.aggregateFragmentMetadata(fragmentMetaInfos);
+					const schemaLevel = resolvedAdapter.schemaLevel;
+					return options.metadata?.({
+						$,
+						document,
+						fragmentMetadata: aggregatedFragmentMetadata,
+						schemaLevel
+					});
+				};
+				if (hasAsyncFragmentMetadata) return Promise.all(fragmentMetadataResults).then(async (resolvedFragmentMetadata) => {
+					return createDefinition(await buildOperationMetadata(resolvedFragmentMetadata));
+				});
+				const operationMetadataResult = buildOperationMetadata(fragmentMetadataResults);
+				if (operationMetadataResult instanceof Promise) return operationMetadataResult.then(createDefinition);
+				return createDefinition(operationMetadataResult);
 			});
 		};
 	};
 };
 
-//#endregion
-//#region packages/core/src/composer/model.ts
-const createGqlModelComposers = (schema) => {
-	const createModelComposer = (typename) => {
-		return (options, builder, normalize) => Model.create(() => {
-			const varDefinitions = require_slice.mergeVarDefinitions(options.variables ?? []);
-			return {
-				typename,
-				fragment: (variables) => {
-					return mergeFields(builder({
-						f: createFieldFactories(schema, typename),
-						$: require_slice.createVarAssignments(varDefinitions, variables)
-					}));
-				},
-				normalize
-			};
-		});
-	};
-	return require_slice.mapValues(schema.object, (_, typename) => createModelComposer(typename));
-};
-
-//#endregion
-//#region packages/core/src/composer/slice.ts
-const createSliceComposerFactory = (schema) => {
-	return (operationType) => {
-		const operationTypeName = schema.operations[operationType];
-		if (operationTypeName === null) throw new Error(`Operation type ${operationType} is not defined in schema roots`);
-		return (options, fieldBuilder, projectionBuilder) => Slice.create(() => {
-			const varDefinitions = require_slice.mergeVarDefinitions(options.variables ?? []);
-			const projection = require_slice.handleProjectionBuilder(projectionBuilder);
-			const { metadata: metadataOption } = options;
-			return {
-				operationType,
-				embed: (variables) => {
-					const f = createFieldFactories(schema, operationTypeName);
-					const $ = require_slice.createVarAssignments(varDefinitions, variables);
-					const fields = mergeFields(fieldBuilder({
-						f,
-						$
-					}));
-					return {
-						variables,
-						getFields: () => fields,
-						projection,
-						metadata: metadataOption?.({ $ })
-					};
-				}
-			};
-		});
-	};
-};
-
-//#endregion
-//#region packages/core/src/types/type-foundation/modified-type-name.ts
-function parseModifiedTypeName(nameAndModifier) {
-	if (typeof nameAndModifier !== "string") throw new Error(`Invalid modified type name: ${nameAndModifier}`);
-	const [name, modifier] = nameAndModifier.split(":");
-	return {
-		name,
-		modifier
-	};
-}
-
 //#endregion
 //#region packages/core/src/composer/var-builder.ts
-const createVarBuilder = (schema) => {
+/**
+* Creates a variable method for a specific input type.
+* This is used by codegen to generate type-specific variable methods.
+*/
+const createVarMethod = (kind, typeName) => {
+	return (modifier, extras) => ({
+		kind,
+		name: typeName,
+		modifier,
+		defaultValue: extras?.default ? { default: extras.default() } : null,
+		directives: extras?.directives ?? {}
+	});
+};
+/**
+* Creates a variable builder that uses injected input type methods.
+*/
+const createVarBuilder = (inputTypeMethods) => {
 	const varBuilder = (varName) => {
-		const createVarSpecifierBuilder = (kind) => {
-			return (type, extras) => wrapByKey(varName, {
-				kind,
-				...parseModifiedTypeName(type),
-				defaultValue: extras?.default ? { default: extras.default() } : null
-			});
-		};
-		return {
-			scalar: createVarSpecifierBuilder("scalar"),
-			enum: createVarSpecifierBuilder("enum"),
-			input: createVarSpecifierBuilder("input"),
-			byField: (typeName, fieldName, argName) => {
-				const argTypeRef = schema.object[typeName]?.fields[fieldName]?.arguments[argName];
-				if (!argTypeRef) throw new Error(`Argument ${argName} not found in field ${fieldName} of type ${typeName}`);
-				return { ...argTypeRef };
-			}
-		};
+		const wrappedMethods = {};
+		for (const [typeName, method] of Object.entries(inputTypeMethods)) Object.defineProperty(wrappedMethods, typeName, {
+			value: ((modifier, extras) => require_schema.wrapByKey(varName, method(modifier, extras))),
+			writable: false,
+			configurable: true
+		});
+		return wrappedMethods;
 	};
-	return { $var: Object.assign(varBuilder, {
-		getName: require_slice.getVarRefName,
-		getValue: require_slice.getVarRefValue,
-		getInner: require_slice.getVarRefInner
-	}) };
+	varBuilder.getName = getVarRefName;
+	varBuilder.getValue = getVarRefValue;
+	varBuilder.getInner = getVarRefInner;
+	return varBuilder;
 };
 
 //#endregion
 //#region packages/core/src/composer/gql-composer.ts
-const createGqlElementComposer = (schema, options = {}) => {
-	const { metadataAdapter, helpers } = options;
-	const model = createGqlModelComposers(schema);
-	const createSliceComposer = createSliceComposerFactory(schema);
-	const createComposedOperationFactory = createComposedOperationComposerFactory({ metadataAdapter });
-	const createInlineOperationComposer = createInlineOperationComposerFactory(schema);
+const createGqlElementComposer = (schema, options) => {
+	const { adapter, inputTypeMethods } = options;
+	const helpers = adapter?.helpers;
+	const metadataAdapter = adapter?.metadata;
+	const fragment = createGqlFragmentComposers(schema, metadataAdapter);
+	const createOperationComposer = createOperationComposerFactory(schema, metadataAdapter);
 	const composers = {
-		model,
-		query: {
-			slice: createSliceComposer("query"),
-			composed: createComposedOperationFactory("query"),
-			inline: createInlineOperationComposer("query")
-		},
-		mutation: {
-			slice: createSliceComposer("mutation"),
-			composed: createComposedOperationFactory("mutation"),
-			inline: createInlineOperationComposer("mutation")
-		},
-		subscription: {
-			slice: createSliceComposer("subscription"),
-			composed: createComposedOperationFactory("subscription"),
-			inline: createInlineOperationComposer("subscription")
-		}
+		fragment,
+		query: { operation: createOperationComposer("query") },
+		mutation: { operation: createOperationComposer("mutation") },
+		subscription: { operation: createOperationComposer("subscription") }
 	};
 	const helper = {
-		...createVarBuilder(schema),
+		$var: createVarBuilder(inputTypeMethods),
+		$colocate: createColocateHelper(),
 		...helpers ?? {}
 	};
 	const elementComposer = (composeElement) => composeElement(composers, helper);
@@ -709,124 +811,37 @@ const createGqlElementComposer = (schema, options = {}) => {
 };
 
 //#endregion
-//#region packages/core/src/composer/helpers.ts
-/**
-* Helper function for defining typed helpers with better inference.
-* Use this when you need explicit typing or when type inference needs assistance.
-*
-* @example
-* ```typescript
-* const gql = createGqlElementComposer(schema, {
-*   helpers: defineHelpers({
-*     auth: {
-*       requiresLogin: () => ({ requiresAuth: true }),
-*       adminOnly: () => ({ requiresAuth: true, role: 'admin' }),
-*     },
-*   }),
-* });
-* ```
-*/
-const defineHelpers = (helpers) => helpers;
-
-//#endregion
-//#region packages/core/src/utils/type-meta.ts
-const withTypeMeta = (target) => {
-	if (process.env.NODE_ENV !== "production") {
-		if (typeof target !== "object" && typeof target !== "function" || target === null) throw new Error("Target must be an object or a function.");
-		Object.defineProperty(target, "$type", { get() {
-			throw new Error("This property is only for type inference. Do not access this property directly.");
-		} });
-	}
-	return target;
-};
-
-//#endregion
-//#region packages/core/src/schema/type-specifier-builder.ts
-const createUnsafeInputTypeSpecifierFactory = (kind) => {
-	return (type, extras) => ({
-		kind,
-		...parseModifiedTypeName(type),
-		defaultValue: extras.default ? { default: extras.default() } : null
-	});
-};
-const unsafeInputType = {
-	scalar: createUnsafeInputTypeSpecifierFactory("scalar"),
-	enum: createUnsafeInputTypeSpecifierFactory("enum"),
-	input: createUnsafeInputTypeSpecifierFactory("input")
-};
-const createUnsafeOutputTypeSpecifierFactory = (kind) => {
-	return (type, extras) => ({
-		kind,
-		...parseModifiedTypeName(type),
-		arguments: extras.arguments ?? {}
-	});
-};
-const unsafeOutputType = {
-	scalar: createUnsafeOutputTypeSpecifierFactory("scalar"),
-	enum: createUnsafeOutputTypeSpecifierFactory("enum"),
-	object: createUnsafeOutputTypeSpecifierFactory("object"),
-	union: createUnsafeOutputTypeSpecifierFactory("union"),
-	typename: createUnsafeOutputTypeSpecifierFactory("typename")
-};
-
-//#endregion
-//#region packages/core/src/schema/schema-builder.ts
-const defineScalar = (name) => wrapByKey(name, withTypeMeta({ name }));
-const define = (name) => ({
-	enum: (values) => withTypeMeta({
-		name,
-		values
-	}),
-	input: (fields) => ({
-		name,
-		fields
-	}),
-	object: (fields) => ({
-		name,
-		fields: {
-			__typename: unsafeOutputType.typename(`${name}:!`, {}),
-			...fields
-		}
-	}),
-	union: (types) => ({
-		name,
-		types
-	})
-});
-const defineOperationRoots = (operationRoots) => operationRoots;
-
-//#endregion
-exports.ComposedOperation = ComposedOperation;
+exports.Fragment = Fragment;
 exports.GqlElement = GqlElement;
-exports.InlineOperation = InlineOperation;
-exports.Model = Model;
-exports.Projection = require_slice.Projection;
-exports.Slice = Slice;
-exports.SlicedExecutionResultEmpty = require_slice.SlicedExecutionResultEmpty;
-exports.SlicedExecutionResultError = require_slice.SlicedExecutionResultError;
-exports.SlicedExecutionResultSuccess = require_slice.SlicedExecutionResultSuccess;
+exports.Operation = Operation;
+exports.appendToPath = appendToPath;
 exports.buildArgumentValue = buildArgumentValue;
 exports.buildConstValueNode = buildConstValueNode;
 exports.buildDocument = buildDocument;
 exports.buildOperationTypeNode = buildOperationTypeNode;
 exports.buildWithTypeModifier = buildWithTypeModifier;
-exports.createComposedOperationComposerFactory = createComposedOperationComposerFactory;
+exports.createColocateHelper = createColocateHelper;
+exports.createDefaultAdapter = createDefaultAdapter;
 exports.createFieldFactories = createFieldFactories;
 exports.createGqlElementComposer = createGqlElementComposer;
-exports.createGqlModelComposers = createGqlModelComposers;
-exports.createPathGraphFromSliceEntries = createPathGraphFromSliceEntries;
-exports.createSliceComposerFactory = createSliceComposerFactory;
-exports.createVarAssignments = require_slice.createVarAssignments;
+exports.createGqlFragmentComposers = createGqlFragmentComposers;
+exports.createOperationComposerFactory = createOperationComposerFactory;
+exports.createVarAssignments = createVarAssignments;
 exports.createVarBuilder = createVarBuilder;
-exports.createVarRefs = require_slice.createVarRefs;
-exports.define = define;
-exports.defineHelpers = defineHelpers;
-exports.defineOperationRoots = defineOperationRoots;
-exports.defineScalar = defineScalar;
-exports.getVarRefInner = require_slice.getVarRefInner;
-exports.getVarRefName = require_slice.getVarRefName;
-exports.getVarRefValue = require_slice.getVarRefValue;
-exports.mergeFields = mergeFields;
-exports.mergeVarDefinitions = require_slice.mergeVarDefinitions;
-exports.unsafeInputType = unsafeInputType;
-exports.unsafeOutputType = unsafeOutputType;
+exports.createVarMethod = createVarMethod;
+exports.createVarRefs = createVarRefs;
+exports.defaultMetadataAdapter = defaultMetadataAdapter;
+exports.define = require_schema.define;
+exports.defineOperationRoots = require_schema.defineOperationRoots;
+exports.defineScalar = require_schema.defineScalar;
+exports.getCurrentFieldPath = getCurrentFieldPath;
+exports.getVarRefInner = getVarRefInner;
+exports.getVarRefName = getVarRefName;
+exports.getVarRefValue = getVarRefValue;
+exports.isListType = isListType;
+exports.recordFragmentUsage = recordFragmentUsage;
+exports.unsafeInputType = require_schema.unsafeInputType;
+exports.unsafeOutputType = require_schema.unsafeOutputType;
+exports.withFieldPath = withFieldPath;
+exports.withFragmentUsageCollection = withFragmentUsageCollection;
+//# sourceMappingURL=index.cjs.map