@fragno-dev/core 0.1.7 → 0.1.9

package/dist/api/fragment-definition-builder.d.ts

@@ -0,0 +1,313 @@
+import { FragnoPublicConfig } from "./shared-types.js";
+import { RequestThisContext } from "./api.js";
+import { RequestContextStorage } from "./request-context-storage.js";
+import { AnyFragnoInstantiatedFragment, FragnoInstantiatedFragment } from "./fragment-instantiator.js";
+
+//#region src/api/fragment-definition-builder.d.ts
+
+/**
+ * Metadata for a service dependency
+ */
+interface ServiceMetadata {
+  /** Name of the service */
+  name: string;
+  /** Whether this service is required (false means optional) */
+  required: boolean;
+}
+/**
+ * Callback that instantiates a linked fragment.
+ * Receives the same context as the main fragment and returns an instantiated fragment.
+ */
+type LinkedFragmentCallback<TConfig, TOptions extends FragnoPublicConfig, TServiceDependencies> = (context: {
+  config: TConfig;
+  options: TOptions;
+  serviceDependencies?: TServiceDependencies;
+}) => FragnoInstantiatedFragment<any, any, any, any, any, any, any>;
+/**
+ * Extract the services type from a FragnoInstantiatedFragment
+ */
+type ExtractLinkedServices<T> = T extends ((...args: never[]) => FragnoInstantiatedFragment<any, any, infer TServices, any, any, any, any>) ? TServices : never;
+/**
+ * Context passed to the request context factory function.
+ */
+type RequestContextFactoryContext<TConfig, TOptions extends FragnoPublicConfig, TDeps, TRequestStorage> = {
+  config: TConfig;
+  options: TOptions;
+  deps: TDeps;
+  storage: RequestContextStorage<TRequestStorage>;
+};
+/**
+ * Context object passed to service constructor functions
+ */
+type ServiceContext<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TServiceThisContext extends RequestThisContext> = {
+  config: TConfig;
+  options: TOptions;
+  deps: TDeps;
+  serviceDeps: TServiceDependencies;
+  privateServices: TPrivateServices;
+  /**
+   * Helper to define services with proper `this` context typing.
+   * Use this to wrap your service methods when they need access to `this`.
+   */
+  defineService: <T>(svc: T & ThisType<TServiceThisContext>) => T;
+};
+/**
+ * Service constructor function type
+ */
+type ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TService, TServiceThisContext extends RequestThisContext> = (context: ServiceContext<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TServiceThisContext>) => TService;
+/**
+ * Fragment definition interface that supports both regular and database fragments.
+ * This is the core definition that will be used for fragment instantiation.
+ */
+interface FragmentDefinition<TConfig, TOptions extends FragnoPublicConfig, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage = {}, TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {}> {
+  name: string;
+  dependencies?: (context: {
+    config: TConfig;
+    options: TOptions;
+  }) => TDeps;
+  baseServices?: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TBaseServices, TServiceThisContext>;
+  namedServices?: { [K in keyof TServices$1]: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TServices$1[K], TServiceThisContext> };
+  privateServices?: { [K in keyof TPrivateServices]: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices,
+  // Private services can access other private services
+  TPrivateServices[K], TServiceThisContext> };
+  serviceDependencies?: { [K in keyof TServiceDependencies]: ServiceMetadata };
+  /**
+   * Optional factory function to create the initial request storage data.
+   * This is called at the start of each request to initialize the storage.
+   * The returned object can be mutated throughout the request lifecycle.
+   *
+   * @example
+   * ```ts
+   * createRequestStorage: ({ config, options, deps }) => ({
+   *   counter: 0,
+   *   userId: deps.currentUserId
+   * })
+   * ```
+   */
+  createRequestStorage?: (context: {
+    config: TConfig;
+    options: TOptions;
+    deps: TDeps;
+  }) => TRequestStorage;
+  /**
+   * Optional factory function to create the this contexts for services and handlers.
+   * Returns separate contexts: serviceContext (may be restricted) and handlerContext (full access).
+   * Both contexts should contain only methods or getters that read from storage.
+   *
+   * @example
+   * ```ts
+   * createThisContext: ({ storage }) => ({
+   *   serviceContext: {
+   *     getUnitOfWork: () => restrictedUOW  // Without execute methods
+   *   },
+   *   handlerContext: {
+   *     getUnitOfWork: () => fullUOW  // With execute methods
+   *   }
+   * })
+   * ```
+   */
+  createThisContext?: (context: RequestContextFactoryContext<TConfig, TOptions, TDeps, TRequestStorage>) => {
+    serviceContext: TServiceThisContext;
+    handlerContext: THandlerThisContext;
+  };
+  /**
+   * Optional factory function to get an external RequestContextStorage instance.
+   * When provided, this storage will be used instead of creating a new one.
+   * This allows multiple fragments to share the same storage (e.g., database fragments sharing adapter storage).
+   *
+   * @example
+   * ```ts
+   * getExternalStorage: ({ options }) => options.databaseAdapter.contextStorage
+   * ```
+   */
+  getExternalStorage?: (context: {
+    config: TConfig;
+    options: TOptions;
+    deps: TDeps;
+  }) => RequestContextStorage<TRequestStorage>;
+  /**
+   * Optional linked fragments that will be automatically instantiated with this fragment.
+   * Linked fragments are service-only and share the same config/options as the parent.
+   */
+  linkedFragments?: { [K in keyof TLinkedFragments]: LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies> };
+  $serviceThisContext?: TServiceThisContext;
+  $handlerThisContext?: THandlerThisContext;
+  $requestStorage?: TRequestStorage;
+  $linkedFragments?: TLinkedFragments;
+}
+/**
+ * Builder class for creating fragment definitions.
+ * This provides a fluent API for defining fragments with type safety.
+ */
+declare class FragmentDefinitionBuilder<TConfig, TOptions extends FragnoPublicConfig, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage = {}, TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {}> {
+  #private;
+  constructor(name: string, state?: {
+    dependencies?: (context: {
+      config: TConfig;
+      options: TOptions;
+    }) => TDeps;
+    baseServices?: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TBaseServices, TServiceThisContext>;
+    namedServices?: { [K in keyof TServices$1]: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TServices$1[K], TServiceThisContext> };
+    privateServices?: { [K in keyof TPrivateServices]: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TPrivateServices[K], TServiceThisContext> };
+    serviceDependencies?: { [K in keyof TServiceDependencies]: ServiceMetadata };
+    createRequestStorage?: (context: {
+      config: TConfig;
+      options: TOptions;
+      deps: TDeps;
+    }) => TRequestStorage;
+    createThisContext?: (context: RequestContextFactoryContext<TConfig, TOptions, TDeps, TRequestStorage>) => {
+      serviceContext: TServiceThisContext;
+      handlerContext: THandlerThisContext;
+    };
+    getExternalStorage?: (context: {
+      config: TConfig;
+      options: TOptions;
+      deps: TDeps;
+    }) => RequestContextStorage<TRequestStorage>;
+    linkedFragments?: { [K in keyof TLinkedFragments]: LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies> };
+  });
+  get name(): string;
+  /**
+   * Define dependencies for this fragment.
+   * Dependencies are available to services and handlers.
+   *
+   * **IMPORTANT**: This method resets all services, storage, and context configurations.
+   * Always call `withDependencies` early in the builder chain, before defining services
+   * or request storage/context.
+   *
+   * @example
+   * ```typescript
+   * // ✅ GOOD: Dependencies set first
+   * defineFragment("my-fragment")
+   *   .withDependencies(() => ({ apiKey: "..." }))
+   *   .withRequestStorage(({ deps }) => ({ userId: deps.apiKey }))
+   *   .providesService("myService", ...)
+   *
+   * // ❌ BAD: Dependencies set late (erases storage setup)
+   * defineFragment("my-fragment")
+   *   .withRequestStorage(() => ({ userId: "..." }))  // This gets erased!
+   *   .withDependencies(() => ({ apiKey: "..." }))
+   * ```
+   */
+  withDependencies<TNewDeps>(fn: (context: {
+    config: TConfig;
+    options: TOptions;
+  }) => TNewDeps): FragmentDefinitionBuilder<TConfig, TOptions, TNewDeps, {}, {}, TServiceDependencies, {}, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Define base (unnamed) services for this fragment.
+   * Base services are accessible directly on the fragment instance.
+   */
+  providesBaseService<TNewService>(fn: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TNewService, TServiceThisContext>): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TNewService, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Provide a named service that other fragments or users can use.
+   * Named services are accessible as fragment.serviceName.method()
+   */
+  providesService<TServiceName extends string, TService>(serviceName: TServiceName, fn: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TService, TServiceThisContext>): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1 & { [K in TServiceName]: TService }, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Provide a private service that is only accessible to the fragment author.
+   * Private services are NOT exposed on the fragment instance, but can be used
+   * when defining other services (baseServices, namedServices, and other privateServices).
+   * Private services are instantiated in order, so earlier private services are available
+   * to later ones.
+   */
+  providesPrivateService<TServiceName extends string, TService>(serviceName: TServiceName, fn: ServiceConstructorFn<TConfig, TOptions, TDeps, TServiceDependencies, TPrivateServices, TService, TServiceThisContext>): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices & { [K in TServiceName]: TService }, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Declare that this fragment uses a required service provided by the runtime.
+   */
+  usesService<TServiceName extends string, TService>(serviceName: TServiceName): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies & { [K in TServiceName]: TService }, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Declare that this fragment uses an optional service provided by the runtime.
+   */
+  usesOptionalService<TServiceName extends string, TService>(serviceName: TServiceName): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies & { [K in TServiceName]: TService | undefined }, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Define the type and initial data stored in AsyncLocalStorage for per-request isolation.
+   * This should be called before withThisContext if you need to store request-specific data.
+   *
+   * @param initializer Function that returns the initial storage data for each request
+   *
+   * @example
+   * ```typescript
+   * .withRequestStorage(({ config, options, deps }) => ({
+   *   counter: 0,
+   *   userId: deps.currentUserId
+   * }))
+   * .withThisContext(({ storage }) => ({
+   *   serviceContext: {
+   *     get counter() { return storage.getStore()!.counter; }
+   *   },
+   *   handlerContext: {
+   *     get counter() { return storage.getStore()!.counter; }
+   *   }
+   * }))
+   * ```
+   */
+  withRequestStorage<TNewRequestStorage>(initializer: (context: {
+    config: TConfig;
+    options: TOptions;
+    deps: TDeps;
+  }) => TNewRequestStorage): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TNewRequestStorage, TLinkedFragments>;
+  /**
+   * Use an externally-provided RequestContextStorage instance.
+   * This allows multiple fragments to share the same storage instance.
+   * Useful when fragments need to coordinate (e.g., database fragments sharing adapter storage).
+   * Note: You must still call withRequestStorage to provide the initial storage data.
+   *
+   * @example
+   * ```typescript
+   * .withExternalRequestStorage(({ options }) =>
+   *   options.databaseAdapter.contextStorage
+   * )
+   * .withRequestStorage(({ options }) => ({
+   *   uow: options.databaseAdapter.db.createUnitOfWork()
+   * }))
+   * ```
+   */
+  withExternalRequestStorage<TNewStorage>(getStorage: (context: {
+    config: TConfig;
+    options: TOptions;
+    deps: TDeps;
+  }) => RequestContextStorage<TNewStorage>): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TNewStorage, TLinkedFragments>;
+  /**
+   * Set the this contexts for services and handlers in this fragment.
+   * Both contexts should contain only methods or getters that read from storage.
+   * This ensures proper per-request isolation via AsyncLocalStorage.
+   *
+   * @example
+   * ```ts
+   * .withThisContext(({ storage }) => ({
+   *   serviceContext: {
+   *     get myNumber() { return storage.getStore()?.myNumber ?? 0; }
+   *   },
+   *   handlerContext: {
+   *     get myNumber() { return storage.getStore()?.myNumber ?? 0; }
+   *   }
+   * }))
+   * ```
+   */
+  withThisContext<TNewServiceThisContext extends RequestThisContext, TNewHandlerThisContext extends RequestThisContext>(fn: (context: RequestContextFactoryContext<TConfig, TOptions, TDeps, TRequestStorage>) => {
+    serviceContext: TNewServiceThisContext;
+    handlerContext: TNewHandlerThisContext;
+  }): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TNewServiceThisContext, TNewHandlerThisContext, TRequestStorage, TLinkedFragments>;
+  /**
+   * Register a linked fragment that will be automatically instantiated.
+   * Linked fragments are service-only (no routes) and share the same config/options as the parent.
+   * All services from the linked fragment will be available as private services.
+   */
+  withLinkedFragment<const TName extends string, TCallback extends LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies>>(name: TName, callback: TCallback): FragmentDefinitionBuilder<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices & ExtractLinkedServices<TCallback>, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments & { [K in TName]: ReturnType<TCallback> }>;
+  /**
+   * Extend this builder with a transformation function.
+   * This enables fluent API extensions like `.extend(withDatabase(schema))`.
+   */
+  extend<const TNewBuilder>(transformer: (builder: this) => TNewBuilder): TNewBuilder;
+  /**
+   * Build the final fragment definition
+   */
+  build(): FragmentDefinition<TConfig, TOptions, TDeps, TBaseServices, TServices$1, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>;
+}
+/**
+ * Create a new fragment definition builder
+ */
+declare function defineFragment<TConfig = {}, TOptions extends FragnoPublicConfig = FragnoPublicConfig, TServiceThisContext extends RequestThisContext = RequestThisContext, THandlerThisContext extends RequestThisContext = RequestThisContext, TRequestStorage = {}>(name: string): FragmentDefinitionBuilder<TConfig, TOptions, {}, {}, {}, {}, {}, TServiceThisContext, THandlerThisContext, TRequestStorage, {}>;
+//#endregion
+export { ExtractLinkedServices, FragmentDefinition, FragmentDefinitionBuilder, LinkedFragmentCallback, RequestContextFactoryContext, ServiceConstructorFn, ServiceContext, defineFragment };
+//# sourceMappingURL=fragment-definition-builder.d.ts.map

package/dist/api/fragment-definition-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-definition-builder.d.ts","names":[],"sources":["../../src/api/fragment-definition-builder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAMiC;AAgBjC,UAXU,eAAA,CAWE;EAEO;EAGT,IAAA,EAAA,MAAA;EACC;EACa,QAAA,EAAA,OAAA;;;AAOxB;;;AAII,KAlBQ,sBAkBR,CAAA,OAAA,EAAA,iBAhBe,kBAgBf,EAAA,oBAAA,CAAA,GAAA,CAAA,OAAA,EAAA;EAAS,MAAA,EAbH,OAaG;EAMD,OAAA,EAlBD,QAkBC;EAEO,mBAAA,CAAA,EAnBK,oBAmBL;CAIT,EAAA,GArBJ,0BAqBI,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA;;;;AAGC,KAnBC,qBAmBD,CAAA,CAAA,CAAA,GAnB4B,CAmB5B,UAAA,CAAA,GAAA,IAAA,EAAA,KAAA,EAAA,EAAA,GAhBN,0BAgBM,CAAA,GAAA,EAAA,GAAA,EAAA,KAAA,UAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,IAfP,SAeO,GAAA,KAAA;;AAMX;;AAQU,KAvBE,4BAuBF,CAAA,OAAA,EAAA,iBArBS,kBAqBT,EAAA,KAAA,EAAA,eAAA,CAAA,GAAA;EACC,MAAA,EAlBD,OAkBC;EACH,OAAA,EAlBG,QAkBH;EACO,IAAA,EAlBP,KAkBO;EACI,OAAA,EAlBR,qBAkBQ,CAlBc,eAkBd,CAAA;CAKO;;;;AAAuC,KAjBrD,cAiBqD,CAAA,OAAA,EAAA,QAAA,EAAA,KAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,4BAXnC,kBAWmC,CAAA,GAAA;EAMrD,MAAA,EAfF,OAeE;EAOkB,OAAA,EArBnB,QAqBmB;EAG1B,IAAA,EAvBI,KAuBJ;EACA,WAAA,EAvBW,oBAuBX;EACA,eAAA,EAvBe,gBAuBf;EACA;;;;EAIC,aAAA,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAvBqB,CAuBrB,GAvByB,QAuBzB,CAvBkC,mBAuBlC,CAAA,EAAA,GAvB2D,CAuB3D;CAAQ;AAMb;;;AAS8B,KAhClB,oBAgCkB,CAAA,OAAA,EAAA,QAAA,EAAA,KAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,QAAA,EAAA,4BAzBA,kBAyBA,CAAA,GAAA,CAAA,OAAA,EAvBnB,cAuBmB,CAtB1B,OAsB0B,EArB1B,QAqB0B,EApB1B,KAoB0B,EAnB1B,oBAmB0B,EAlB1B,gBAkB0B,EAjB1B,mBAiB0B,CAAA,EAAA,GAfzB,QAeyB;;;;;AAOwC,UAhBrD,kBAgBqD,CAAA,OAAA,EAAA,iBAdnD,kBAcmD,EAAA,KAAA,EAAA,aAAA,EAAA,WAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,4BARxC,kBAQwC,EAAA,4BAPxC,kBAOwC,EAAA,kBAAA,CAAA,CAAA,EAAA,yBAL3C,MAK2C,CAAA,MAAA,EAL5B,6BAK4B,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAGlE,IAAA,EAAA,MAAA;EACA,YAAA,CAAA,EAAA,CAAA,OAAA,EAAA;IACA,MAAA,EALiC,OAKjC;IACA,OAAA,EANmD,QAMnD;EACA,CAAA,EAAA,GAPkE,KAOlE;EACA,YAAA,CAAA,EANa,oBAMb,CALA,OAKA,EAJA,QAIA,EAHA,KAGA,EAFA,oBAEA,EADA,gBACA,EAAA,aAAA,EACA,mBADA,CAAA;EACA,aAAA,CAAA,EAAA,QAPa,MAYD,WAZC,GAYW,oBAZX,CAaX,OAbW,EAcX,QAdW,EAeX,KAfW,EAgBX,oBAhBW,EAiBX,gBAjBW,EAkBX,WAlBW,CAkBD,CAlBC,CAAA,EAmBX,mBAnBW,CAAA,EAYD;EACV,eAAA,CAAA,EAAA,QACA,MAWU,gBAXV,GAW6B,oBAX7B,CAYA,OAZA,EAaA,QAbA,EAcA,KAdA,EAeA,oBAfA,EAgBA,gBAhBA;EAAA;EAiBA,gBAhBA,CAgBiB,CAhBjB,CAAA,EAiBA,mBAjBA,CAAA,EACA;EACA,mBAAA,CAAA,EAAA,QACA,MAoBU,oBApBV,GAoBiC,eApBjC,EAAU;EACV;;;;;;;;;;;;;EAmBiC,oBAAA,CAAA,EAAA,CAAA,OAAA,EAAA;IAiB3B,MAAA,EAAA,OAAA;IACC,OAAA,EAAA,QAAA;IACH,IAAA,EAAA,KAAA;EACF,CAAA,EAAA,GAAA,eAAA;EAoBkC;;;;;;;;;;;;;;;;;EA8BlB,iBAAA,CAAA,EAAA,CAAA,OAAA,EA9BX,4BA8BW,CA9BkB,OA8BlB,EA9B2B,QA8B3B,EA9BqC,KA8BrC,EA9B4C,eA8B5C,CAAA,EAAA,GAAA;IACA,cAAA,EA7BJ,mBA6BI;IACJ,cAAA,EA7BA,mBA6BA;EACC,CAAA;EAAgB;AAOrC;;;;;;;;;EA0EQ,kBAAA,CAAA,EAAA,CAAA,OAAA,EAAA;IACA,MAAA,EAlGI,OAkGJ;IACA,OAAA,EAlGK,QAkGL;IACA,IAAA,EAlGE,KAkGF;EACA,CAAA,EAAA,GAlGA,qBAkGA,CAlGsB,eAkGtB,CAAA;EACA;;;;EAKE,eAAA,CAAA,EAAA,QACA,MAlGM,gBAkGN,GAlGyB,sBAkGzB,CAlGgD,OAkGhD,EAlGyD,QAkGzD,EAlGmE,oBAkGnE,CAAA,EACA;EACA,mBAAA,CAAA,EAjGc,mBAiGd;EACA,mBAAA,CAAA,EAjGc,mBAiGd;EACA,eAAA,CAAA,EAjGU,eAiGV;EAAU,gBAAA,CAAA,EAhGC,gBAgGD;;;;;;AAQV,cAjGG,yBAiGH,CAAA,OAAA,EAAA,iBA/FS,kBA+FT,EAAA,KAAA,EAAA,aAAA,EAAA,WAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,4BAzFoB,kBAyFpB,EAAA,4BAxFoB,kBAwFpB,EAAA,kBAAA,CAAA,CAAA,EAAA,yBAtFiB,MAsFjB,CAAA,MAAA,EAtFgC,6BAsFhC,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EACA,CAAA,OAAA;EACA,WAAA,CAAA,IAAA,EAAA,MAAA,EAAA,KA6EN,CA7EM,EAAA;IACA,YAAA,CAAA,EAAA,CAAA,OAAA,EAAA;MAAiB,MAAA,EA5Bc,OA4Bd;MACjB,OAAA,EA7BiD,QA6BjD;IAP6B,CAAA,EAAA,GAtBmC,KAsBnC;IAWnB,YAAA,CAAA,EAhCC,oBAgCD,CA/BZ,OA+BY,EA9BZ,QA8BY,EA7BZ,KA6BY,EA5BZ,oBA4BY,EA3BZ,gBA2BY,EA1BZ,aA0BY,EAzBZ,mBAyBY,CAAA;IAAuB,aAAA,CAAA,EAAA,QAG3B,MAzBI,WAyBJ,GAzBgB,oBAyBhB,CAxBN,OAwBM,EAvBN,QAuBM,EAtBN,KAsBM,EArBN,oBAqBM,EApBN,gBAoBM,EAnBN,WAmBM,CAnBI,CAmBJ,CAAA,EAlBN,mBAkBM,CAAA,EACC;IACH,eAAA,CAAA,EAAA,QACF,MAjBQ,gBAiBR,GAjB2B,oBAiB3B,CAhBF,OAgBE,EAfF,QAeE,EAdF,KAcE,EAbF,oBAaE,EAZF,gBAYE,EAXF,gBAWE,CAXe,CAWf,CAAA,EAVF,mBAUE,CAAA,EAEkC;IAAS,mBAAA,CAAA,EAAA,QAAU,MAR7C,oBAQ6C,GARtB,eAQsB,EAAO;IAAvD,oBAAA,CAAA,EAAA,CAAA,OAAA,EAAA;MAEO,MAAA,EAPR,OAOQ;MACA,OAAA,EAPP,QAOO;MAGR,IAAA,EATF,KASE;IACC,CAAA,EAAA,GATL,eASK;IACH,iBAAA,CAAA,EAAA,CAAA,OAAA,EARG,4BAQH,CARgC,OAQhC,EARyC,QAQzC,EARmD,KAQnD,EAR0D,eAQ1D,CAAA,EAAA,GAAA;MACoB,cAAA,EAPV,mBAOU;MAAtB,cAAA,EANY,mBAMZ;IAEQ,CAAA;IACV,kBAAA,CAAA,EAAA,CAAA,OAAA,EAAA;MACA,MAAA,EAPM,OAON;MACA,OAAA,EAPO,QAOP;MAH6B,IAAA,EAHzB,KAGyB;IAiDX,CAAA,EAAA,GAnDhB,qBAmDgB,CAnDM,eAmDN,CAAA;IAAkB,eAAA,CAAA,EAAA,QAAe,MAjDzC,gBAiDyC,GAjDtB,sBAiDsB,CAhDnD,OAgDmD,EA/CnD,QA+CmD,EA9CnD,oBA8CmD,CAAA,EAEzD;EACA,CAAA;EACA,IAAA,IAAA,CAAA,CAAA,EAAA,MAAA;EAGA;;;;;;;;;;;;;;;;;;;;;;EAuEA,gBAAA,CAAA,QAAA,CAAA,CAAA,EAAA,EAAA,CAAA,OAAA,EAAA;IACA,MAAA,EA/EwB,OA+ExB;IACA,OAAA,EAhF0C,QAgF1C;EAXC,CAAA,EAAA,GArEwD,QAqExD,CAAA,EApEA,yBAoEA,CAnED,OAmEC,EAlED,QAkEC,EAjED,QAiEC,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EA9DD,oBA8DC,EAAA,CAAA,CAAA,EA5DD,mBA4DC,EA3DD,mBA2DC,EA1DD,eA0DC,EAzDD,gBAyDC,CAAA;EA2CY;;;;EAKX,mBAAA,CAAA,WAAA,CAAA,CAAA,EAAA,EAzDE,oBAyDF,CAxDA,OAwDA,EAvDA,QAuDA,EAtDA,KAsDA,EArDA,oBAqDA,EApDA,gBAoDA,EAnDA,WAmDA,EAlDA,mBAkDA,CAAA,CAAA,EAhDD,yBAgDC,CA/CF,OA+CE,EA9CF,QA8CE,EA7CF,KA6CE,EA5CF,WA4CE,EA3CF,WA2CE,EA1CF,oBA0CE,EAzCF,gBAyCE,EAxCF,mBAwCE,EAvCF,mBAuCE,EAtCF,eAsCE,EArCF,gBAqCE,CAAA;EACA;;;;EAKF,eAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAXa,YAWb,EAAA,EAAA,EAVI,oBAUJ,CATE,OASF,EARE,QAQF,EAPE,KAOF,EANE,oBAMF,EALE,gBAKF,EAJE,QAIF,EAHE,mBAGF,CAAA,CAAA,EADC,yBACD,CAAA,OAAA,EACA,QADA,EAEA,KAFA,EAGA,aAHA,EAIA,WAJA,GAAA,QAIoB,YAHpB,GAGmC,QAHnC,EACA,EAGA,oBAHA,EAIA,gBAJA,EAKA,mBALA,EAMA,mBANA,EAOA,eAPA,EAQA,gBARA,CAAA;EACA;;;;;;;EAKA,sBAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAqDa,YArDb,EAAA,EAAA,EAsDI,oBAtDJ,CAuDE,OAvDF,EAwDE,QAxDF,EAyDE,KAzDF,EA0DE,oBA1DF,EA2DE,gBA3DF,EA4DE,QA5DF,EA6DE,mBA7DF,CAAA,CAAA,EA+DC,yBA/DD,CAgEA,OAhEA,EAiEA,QAjEA,EAkEA,KAlEA,EAmEA,aAnEA,EAoEA,WApEA,EAqEA,oBArEA,EAsEA,gBAtEA,GAAA,QAsE2B,YArE3B,GAqE0C,QArE1C,EACA,EAqEA,mBArEA,EAsEA,mBAtEA,EAuEA,eAvEA,EAwEA,gBAxEA,CAAA;EAXC;;;EAiEC,WAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAgEW,YAhEX,CAAA,EAiED,yBAjEC,CAkEF,OAlEE,EAmEF,QAnEE,EAoEF,KApEE,EAqEF,aArEE,EAsEF,WAtEE,EAuEF,oBAvEE,GAAA,QAuE6B,YAtE7B,GAsE4C,QAtE5C,EACA,EAsEF,gBAtEE,EAuEF,mBAvEE,EAwEF,mBAxEE,EAyEF,eAzEE,EA0EF,gBA1EE,CAAA;EACA;;;EALE,mBAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAoHS,YApHT,CAAA,EAqHH,yBArHG,CAsHJ,OAtHI,EAuHJ,QAvHI,EAwHJ,KAxHI,EAyHJ,aAzHI,EA0HJ,WA1HI,EA2HJ,oBA3HI,GAAA,QA2H2B,YAjH/B,GAiH8C,QAjH9C,GAAA,SAAA,EACA,EAiHA,gBAjHA,EAkHA,mBAlHA,EAmHA,mBAnHA,EAoHA,eApHA,EAqHA,gBArHA,CAAA;EACA;;;;;;;;;;;;;;;;;;;;;;EA+DA,kBAAA,CAAA,kBAAA,CAAA,CAAA,WAAA,EAAA,CAAA,OAAA,EAAA;IACA,MAAA,EAgHU,OAhHV;IACA,OAAA,EAgHW,QAhHX;IACA,IAAA,EAgHQ,KAhHR;EAXC,CAAA,EAAA,GA4HK,kBA5HL,CAAA,EA6HA,yBA7HA,CA8HD,OA9HC,EA+HD,QA/HC,EAgID,KAhIC,EAiID,aAjIC,EAkID,WAlIC,EAmID,oBAnIC,EAoID,gBApIC,EAqID,mBArIC,EAsID,mBAtIC,EAuID,kBAvIC,EAwID,gBAxIC,CAAA;EAiDY;;;;;;;;;;;;;;;;EAyEF,0BAAA,CAAA,WAAA,CAAA,CAAA,UAAA,EAAA,CAAA,OAAA,EAAA;IACH,MAAA,EAqEE,OArEF;IACF,OAAA,EAqEK,QArEL;IAEN,IAAA,EAoEQ,KApER;EACA,CAAA,EAAA,GAoEM,qBApEN,CAoE4B,WApE5B,CAAA,CAAA,EAqEC,yBArED,CAsEA,OAtEA,EAuEA,QAvEA,EAwEA,KAxEA,EAyEA,aAzEA,EA0EA,WA1EA,EA2EA,oBA3EA,EA4EA,gBA5EA,EA6EA,mBA7EA,EA8EA,mBA9EA,EA+EA,WA/EA,EAgFA,gBAhFA,CAAA;EACA;;;;;;;;;;;;;;;;;EAuEA,eAAA,CAAA,+BAsD+B,kBAtD/B,EAAA,+BAuD+B,kBAvD/B,CAAA,CAAA,EAAA,EAAA,CAAA,OAAA,EAyDc,4BAzDd,CAyD2C,OAzD3C,EAyDoD,QAzDpD,EAyD8D,KAzD9D,EAyDqE,eAzDrE,CAAA,EAAA,GAAA;IACA,cAAA,EAyDkB,sBAzDlB;IACA,cAAA,EAyDkB,sBAzDlB;EACA,CAAA,CAAA,EA0DC,yBA1DD,CA2DA,OA3DA,EA4DA,QA5DA,EA6DA,KA7DA,EA8DA,aA9DA,EA+DA,WA/DA,EAgEA,oBAhEA,EAiEA,gBAjEA,EAkEA,sBAlEA,EAmEA,sBAnEA,EAoEA,eApEA,EAqEA,gBArEA,CAAA;EACA;;;;;EAPC,kBAAA,CAAA,oBAAA,MAAA,EAAA,kBA6GiB,sBA7GjB,CA6GwC,OA7GxC,EA6GiD,QA7GjD,EA6G2D,oBA7G3D,CAAA,CAAA,CAAA,IAAA,EA+GK,KA/GL,EAAA,QAAA,EAgHS,SAhHT,CAAA,EAiHA,yBAjHA,CAkHD,OAlHC,EAmHD,QAnHC,EAoHD,KApHC,EAqHD,aArHC,EAsHD,WAtHC,EAuHD,oBAvHC,EAwHD,gBAxHC,GAwHkB,qBAxHlB,CAwHwC,SAxHxC,CAAA,EAyHD,mBAzHC,EA0HD,mBA1HC,EA2HD,eA3HC,EA4HD,gBA5HC,GAAA,QA4H0B,KAnEI,GAmEI,UAnEJ,CAmEe,SAnEf,CAAA,EACA,CAAA;EAEY;;;;EAA7B,MAAA,CAAA,iBAAA,CAAA,CAAA,WAAA,EAAA,CAAA,OAAA,EAAA,IAAA,EAAA,GAuG0C,WAvG1C,CAAA,EAuGwD,WAvGxD;EACI;;;EAKlB,KAAA,CAAA,CAAA,EAwGO,kBAxGP,CAyGA,OAzGA,EA0GA,QA1GA,EA2GA,KA3GA,EA4GA,aA5GA,EA6GA,WA7GA,EA8GA,oBA9GA,EA+GA,gBA/GA,EAgHA,mBAhHA,EAiHA,mBAjHA,EAkHA,eAlHA,EAmHA,gBAnHA,CAAA;;;;;AAKA,iBAkIY,cAlIZ,CAAA,UAAA,CAAA,CAAA,EAAA,iBAoIe,kBApIf,GAoIoC,kBApIpC,EAAA,4BAqI0B,kBArI1B,GAqI+C,kBArI/C,EAAA,4BAsI0B,kBAtI1B,GAsI+C,kBAtI/C,EAAA,kBAAA,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EA0ID,yBA1IC,CA2IF,OA3IE,EA4IF,QA5IE,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EAkJF,mBAlJE,EAmJF,mBAnJE,EAoJF,eApJE,EAAA,CAAA,CAAA,CAAA"}

package/dist/api/fragment-definition-builder.js

@@ -0,0 +1,326 @@
+//#region src/api/fragment-definition-builder.ts
+/**
+* Builder class for creating fragment definitions.
+* This provides a fluent API for defining fragments with type safety.
+*/
+var FragmentDefinitionBuilder = class FragmentDefinitionBuilder {
+	#name;
+	#dependencies;
+	#baseServices;
+	#namedServices;
+	#privateServices;
+	#serviceDependencies;
+	#createRequestStorage;
+	#createThisContext;
+	#getExternalStorage;
+	#linkedFragments;
+	constructor(name, state) {
+		this.#name = name;
+		if (state) {
+			this.#dependencies = state.dependencies;
+			this.#baseServices = state.baseServices;
+			this.#namedServices = state.namedServices;
+			this.#privateServices = state.privateServices;
+			this.#serviceDependencies = state.serviceDependencies;
+			this.#createRequestStorage = state.createRequestStorage;
+			this.#createThisContext = state.createThisContext;
+			this.#getExternalStorage = state.getExternalStorage;
+			this.#linkedFragments = state.linkedFragments;
+		}
+	}
+	get name() {
+		return this.#name;
+	}
+	/**
+	* Define dependencies for this fragment.
+	* Dependencies are available to services and handlers.
+	*
+	* **IMPORTANT**: This method resets all services, storage, and context configurations.
+	* Always call `withDependencies` early in the builder chain, before defining services
+	* or request storage/context.
+	*
+	* @example
+	* ```typescript
+	* // ✅ GOOD: Dependencies set first
+	* defineFragment("my-fragment")
+	*   .withDependencies(() => ({ apiKey: "..." }))
+	*   .withRequestStorage(({ deps }) => ({ userId: deps.apiKey }))
+	*   .providesService("myService", ...)
+	*
+	* // ❌ BAD: Dependencies set late (erases storage setup)
+	* defineFragment("my-fragment")
+	*   .withRequestStorage(() => ({ userId: "..." }))  // This gets erased!
+	*   .withDependencies(() => ({ apiKey: "..." }))
+	* ```
+	*/
+	withDependencies(fn) {
+		if (this.#baseServices || this.#namedServices || this.#privateServices || this.#createRequestStorage || this.#createThisContext || this.#getExternalStorage) console.warn(`[Fragno] Warning: withDependencies() on fragment "${this.#name}" is resetting previously configured services, request storage, or request context. To avoid this, call withDependencies() earlier in the builder chain, before configuring services or storage.`);
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: fn,
+			baseServices: void 0,
+			namedServices: void 0,
+			privateServices: void 0,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: void 0,
+			createThisContext: void 0,
+			getExternalStorage: void 0,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Define base (unnamed) services for this fragment.
+	* Base services are accessible directly on the fragment instance.
+	*/
+	providesBaseService(fn) {
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: fn,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			getExternalStorage: this.#getExternalStorage,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Provide a named service that other fragments or users can use.
+	* Named services are accessible as fragment.serviceName.method()
+	*/
+	providesService(serviceName, fn) {
+		const newNamedServices = {
+			...this.#namedServices,
+			[serviceName]: fn
+		};
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: newNamedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			getExternalStorage: this.#getExternalStorage,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Provide a private service that is only accessible to the fragment author.
+	* Private services are NOT exposed on the fragment instance, but can be used
+	* when defining other services (baseServices, namedServices, and other privateServices).
+	* Private services are instantiated in order, so earlier private services are available
+	* to later ones.
+	*/
+	providesPrivateService(serviceName, fn) {
+		const newPrivateServices = {
+			...this.#privateServices,
+			[serviceName]: fn
+		};
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: newPrivateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Declare that this fragment uses a required service provided by the runtime.
+	*/
+	usesService(serviceName) {
+		const newServiceDependencies = {
+			...this.#serviceDependencies,
+			[serviceName]: {
+				name: serviceName,
+				required: true
+			}
+		};
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: newServiceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Declare that this fragment uses an optional service provided by the runtime.
+	*/
+	usesOptionalService(serviceName) {
+		const newServiceDependencies = {
+			...this.#serviceDependencies,
+			[serviceName]: {
+				name: serviceName,
+				required: false
+			}
+		};
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: newServiceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Define the type and initial data stored in AsyncLocalStorage for per-request isolation.
+	* This should be called before withThisContext if you need to store request-specific data.
+	*
+	* @param initializer Function that returns the initial storage data for each request
+	*
+	* @example
+	* ```typescript
+	* .withRequestStorage(({ config, options, deps }) => ({
+	*   counter: 0,
+	*   userId: deps.currentUserId
+	* }))
+	* .withThisContext(({ storage }) => ({
+	*   serviceContext: {
+	*     get counter() { return storage.getStore()!.counter; }
+	*   },
+	*   handlerContext: {
+	*     get counter() { return storage.getStore()!.counter; }
+	*   }
+	* }))
+	* ```
+	*/
+	withRequestStorage(initializer) {
+		const preservedExternalStorage = this.#getExternalStorage ? this.#getExternalStorage : void 0;
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: initializer,
+			createThisContext: void 0,
+			getExternalStorage: preservedExternalStorage,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Use an externally-provided RequestContextStorage instance.
+	* This allows multiple fragments to share the same storage instance.
+	* Useful when fragments need to coordinate (e.g., database fragments sharing adapter storage).
+	* Note: You must still call withRequestStorage to provide the initial storage data.
+	*
+	* @example
+	* ```typescript
+	* .withExternalRequestStorage(({ options }) =>
+	*   options.databaseAdapter.contextStorage
+	* )
+	* .withRequestStorage(({ options }) => ({
+	*   uow: options.databaseAdapter.db.createUnitOfWork()
+	* }))
+	* ```
+	*/
+	withExternalRequestStorage(getStorage) {
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: void 0,
+			createThisContext: void 0,
+			getExternalStorage: getStorage,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Set the this contexts for services and handlers in this fragment.
+	* Both contexts should contain only methods or getters that read from storage.
+	* This ensures proper per-request isolation via AsyncLocalStorage.
+	*
+	* @example
+	* ```ts
+	* .withThisContext(({ storage }) => ({
+	*   serviceContext: {
+	*     get myNumber() { return storage.getStore()?.myNumber ?? 0; }
+	*   },
+	*   handlerContext: {
+	*     get myNumber() { return storage.getStore()?.myNumber ?? 0; }
+	*   }
+	* }))
+	* ```
+	*/
+	withThisContext(fn) {
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: fn,
+			getExternalStorage: this.#getExternalStorage,
+			linkedFragments: this.#linkedFragments
+		});
+	}
+	/**
+	* Register a linked fragment that will be automatically instantiated.
+	* Linked fragments are service-only (no routes) and share the same config/options as the parent.
+	* All services from the linked fragment will be available as private services.
+	*/
+	withLinkedFragment(name, callback) {
+		const newLinkedFragments = {
+			...this.#linkedFragments,
+			[name]: callback
+		};
+		return new FragmentDefinitionBuilder(this.#name, {
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			getExternalStorage: this.#getExternalStorage,
+			linkedFragments: newLinkedFragments
+		});
+	}
+	/**
+	* Extend this builder with a transformation function.
+	* This enables fluent API extensions like `.extend(withDatabase(schema))`.
+	*/
+	extend(transformer) {
+		return transformer(this);
+	}
+	/**
+	* Build the final fragment definition
+	*/
+	build() {
+		return {
+			name: this.#name,
+			dependencies: this.#dependencies,
+			baseServices: this.#baseServices,
+			namedServices: this.#namedServices,
+			privateServices: this.#privateServices,
+			serviceDependencies: this.#serviceDependencies,
+			createRequestStorage: this.#createRequestStorage,
+			createThisContext: this.#createThisContext,
+			getExternalStorage: this.#getExternalStorage,
+			linkedFragments: this.#linkedFragments
+		};
+	}
+};
+/**
+* Create a new fragment definition builder
+*/
+function defineFragment(name) {
+	return new FragmentDefinitionBuilder(name);
+}
+
+//#endregion
+export { FragmentDefinitionBuilder, defineFragment };
+//# sourceMappingURL=fragment-definition-builder.js.map