@fragno-dev/core 0.1.11 → 0.2.0

package/dist/runtime.d.ts

@@ -0,0 +1,15 @@
+//#region src/runtime.d.ts
+type FragnoRuntime = {
+  time: {
+    now: () => Date;
+  };
+  random: {
+    float: () => number;
+    uuid: () => string;
+    cuid: () => string;
+  };
+};
+declare const defaultFragnoRuntime: FragnoRuntime;
+//#endregion
+export { FragnoRuntime, defaultFragnoRuntime };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../src/runtime.ts"],"sourcesContent":[],"mappings":";KAEY,aAAA;EAAA,IAAA,EAAA;IAoCC,GAAA,EAAA,GAAA,GAlCE,IAkCF;;;;;;;;cAAA,sBAAsB"}

package/dist/runtime.js

@@ -0,0 +1,33 @@
+import { createId } from "@paralleldrive/cuid2";
+
+//#region src/runtime.ts
+const fallbackUuid = () => {
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+	return [
+		hex.slice(0, 4).join(""),
+		hex.slice(4, 6).join(""),
+		hex.slice(6, 8).join(""),
+		hex.slice(8, 10).join(""),
+		hex.slice(10, 16).join("")
+	].join("-");
+};
+const defaultUuid = () => {
+	const cryptoApi = globalThis.crypto;
+	return cryptoApi?.randomUUID ? cryptoApi.randomUUID() : fallbackUuid();
+};
+const defaultFragnoRuntime = {
+	time: { now: () => /* @__PURE__ */ new Date() },
+	random: {
+		float: () => Math.random(),
+		uuid: () => defaultUuid(),
+		cuid: () => createId()
+	}
+};
+
+//#endregion
+export { defaultFragnoRuntime };
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":["defaultFragnoRuntime: FragnoRuntime"],"sources":["../src/runtime.ts"],"sourcesContent":["import { createId } from \"@paralleldrive/cuid2\";\n\nexport type FragnoRuntime = {\n  time: {\n    now: () => Date;\n  };\n  random: {\n    float: () => number;\n    uuid: () => string;\n    cuid: () => string;\n  };\n};\n\nconst fallbackUuid = () => {\n  const bytes = new Uint8Array(16);\n  for (let i = 0; i < bytes.length; i += 1) {\n    bytes[i] = Math.floor(Math.random() * 256);\n  }\n\n  // RFC 4122 variant + version 4\n  bytes[6] = (bytes[6] & 0x0f) | 0x40;\n  bytes[8] = (bytes[8] & 0x3f) | 0x80;\n\n  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\"));\n  return [\n    hex.slice(0, 4).join(\"\"),\n    hex.slice(4, 6).join(\"\"),\n    hex.slice(6, 8).join(\"\"),\n    hex.slice(8, 10).join(\"\"),\n    hex.slice(10, 16).join(\"\"),\n  ].join(\"-\");\n};\n\nconst defaultUuid = () => {\n  const cryptoApi = globalThis.crypto;\n  return cryptoApi?.randomUUID ? cryptoApi.randomUUID() : fallbackUuid();\n};\n\nexport const defaultFragnoRuntime: FragnoRuntime = {\n  time: {\n    now: () => new Date(),\n  },\n  random: {\n    float: () => Math.random(),\n    uuid: () => defaultUuid(),\n    cuid: () => createId(),\n  },\n};\n"],"mappings":";;;AAaA,MAAM,qBAAqB;CACzB,MAAM,QAAQ,IAAI,WAAW,GAAG;AAChC,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,OAAM,KAAK,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAI;AAI5C,OAAM,KAAM,MAAM,KAAK,KAAQ;AAC/B,OAAM,KAAM,MAAM,KAAK,KAAQ;CAE/B,MAAM,MAAM,MAAM,KAAK,QAAQ,SAAS,KAAK,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;AAC3E,QAAO;EACL,IAAI,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG;EACxB,IAAI,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG;EACxB,IAAI,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG;EACxB,IAAI,MAAM,GAAG,GAAG,CAAC,KAAK,GAAG;EACzB,IAAI,MAAM,IAAI,GAAG,CAAC,KAAK,GAAG;EAC3B,CAAC,KAAK,IAAI;;AAGb,MAAM,oBAAoB;CACxB,MAAM,YAAY,WAAW;AAC7B,QAAO,WAAW,aAAa,UAAU,YAAY,GAAG,cAAc;;AAGxE,MAAaA,uBAAsC;CACjD,MAAM,EACJ,2BAAW,IAAI,MAAM,EACtB;CACD,QAAQ;EACN,aAAa,KAAK,QAAQ;EAC1B,YAAY,aAAa;EACzB,YAAY,UAAU;EACvB;CACF"}

package/dist/test/test.d.ts

@@ -4,7 +4,7 @@ import { RequestThisContext } from "../api/api.js";
 import { BoundServices } from "../api/bind-services.js";
 import { AnyRouteOrFactory, FlattenRouteFactories } from "../api/route.js";
 import { FragnoResponse } from "../api/fragno-response.js";
-import { FragnoInstantiatedFragment } from "../api/fragment-instantiator.js";
+import { AnyFragnoInstantiatedFragment, FragnoInstantiatedFragment, RoutesWithInternal } from "../api/fragment-instantiator.js";
 import { FragmentDefinition, FragmentDefinitionBuilder } from "../api/fragment-definition-builder.js";
 
 //#region src/test/test.d.ts
@@ -87,7 +87,7 @@ interface CreateFragmentForTestOptions<TConfig, TOptions extends FragnoPublicCon
  * }
  * ```
  */
-declare function createFragmentForTest<TConfig, TOptions extends FragnoPublicConfig, TDeps, TBaseServices extends Record<string, unknown>, TServices extends Record<string, unknown>, TServiceDependencies, TPrivateServices extends Record<string, unknown>, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage, const TRoutesOrFactories extends readonly AnyRouteOrFactory[]>(definition: FragmentDefinition<TConfig, TOptions, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage>, routesOrFactories: TRoutesOrFactories, options: CreateFragmentForTestOptions<TConfig, TOptions, TServiceDependencies>): FragnoInstantiatedFragment<FlattenRouteFactories<TRoutesOrFactories>, TDeps, BoundServices<TBaseServices & TServices>, TServiceThisContext, THandlerThisContext, TRequestStorage>;
+declare function createFragmentForTest<TConfig, TOptions extends FragnoPublicConfig, TDeps, TBaseServices extends Record<string, unknown>, TServices extends Record<string, unknown>, TServiceDependencies, TPrivateServices extends Record<string, unknown>, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage, const TRoutesOrFactories extends readonly AnyRouteOrFactory[], TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {}>(definition: FragmentDefinition<TConfig, TOptions, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>, routesOrFactories: TRoutesOrFactories, options: CreateFragmentForTestOptions<TConfig, TOptions, TServiceDependencies>): FragnoInstantiatedFragment<RoutesWithInternal<FlattenRouteFactories<TRoutesOrFactories>, TLinkedFragments>, TDeps, BoundServices<TBaseServices & TServices>, TServiceThisContext, THandlerThisContext, TRequestStorage, TOptions, TLinkedFragments>;
 //#endregion
 export { CreateFragmentForTestOptions, type FragnoResponse, type RouteHandlerInputOptions, TestBaseServices, createFragmentForTest, withTestUtils };
 //# sourceMappingURL=test.d.ts.map

package/dist/test/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","names":[],"sources":["../../src/test/test.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAeY;;AAAZ;AAsBA;EAGqB,IAAA,EArBb,KAqBa;CAMW;;;;;;;;;;;;;;;;AAoB5B,iBA7BY,aAAA,CAAA,CA6BZ,EAAA,CAAA,OAAA,EAAA,iBA1BiB,kBA0BjB,EAAA,KAAA,EAAA,aAAA,EAAA,SAAA,EAAA,YAAA,EAAA,gBAAA,EAAA,4BApB4B,kBAoB5B,EAAA,4BAnB4B,kBAmB5B,EAAA,eAAA,CAAA,CAAA,OAAA,EAhBS,yBAgBT,CAfE,OAeF,EAdE,QAcF,EAbE,KAaF,EAZE,aAYF,EAXE,SAWF,EAVE,YAUF,EATE,gBASF,EARE,mBAQF,EAPE,mBAOF,EANE,eAMF,CAAA,EAAA,GAJC,yBAID,CAHA,OAGA,EAFA,QAEA,EADA,KACA,EAAA,aAAA,GAAgB,gBAAhB,CAAiC,KAAjC,CAAA,EACA,SADA,EAEA,YAFA,EAGA,gBAHA,EAIA,mBAJA,EAKA,mBALA,EAMA,eANA,CAAA;;;;AAEA,UA+Da,4BA/Db,CAAA,OAAA,EAAA,iBAiEe,kBAjEf,EAAA,oBAAA,CAAA,CAAA;EACA,MAAA,EAmEM,OAnEN;EACA,OAAA,CAAA,EAmEQ,OAnER,CAmEgB,QAnEhB,CAAA;EACA,sBAAA,CAAA,EAmEuB,oBAnEvB;;;;AA4DJ;;;;;;;AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,gDAEG,iDAEK,2CACJ,wEAEO,qDACG,gDACA,+EAEc,iCAE9B,mBACV,SACA,UACA,OACA,eACA,WACA,sBACA,kBACA,qBACA,qBACA,qCAEiB,6BACV,6BAA6B,SAAS,UAAU,wBACxD,2BACD,sBAAsB,qBACtB,OACA,cAAc,gBAAgB,YAC9B,qBACA,qBACA"}
+{"version":3,"file":"test.d.ts","names":[],"sources":["../../src/test/test.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAoBY;;AAAZ;AAsBA;EAGqB,IAAA,EArBb,KAqBa;CAMW;;;;;;;;;;;;;;;;AAoB5B,iBA7BY,aAAA,CAAA,CA6BZ,EAAA,CAAA,OAAA,EAAA,iBA1BiB,kBA0BjB,EAAA,KAAA,EAAA,aAAA,EAAA,SAAA,EAAA,YAAA,EAAA,gBAAA,EAAA,4BApB4B,kBAoB5B,EAAA,4BAnB4B,kBAmB5B,EAAA,eAAA,CAAA,CAAA,OAAA,EAhBS,yBAgBT,CAfE,OAeF,EAdE,QAcF,EAbE,KAaF,EAZE,aAYF,EAXE,SAWF,EAVE,YAUF,EATE,gBASF,EARE,mBAQF,EAPE,mBAOF,EANE,eAMF,CAAA,EAAA,GAJC,yBAID,CAHA,OAGA,EAFA,QAEA,EADA,KACA,EAAA,aAAA,GAAgB,gBAAhB,CAAiC,KAAjC,CAAA,EACA,SADA,EAEA,YAFA,EAGA,gBAHA,EAIA,mBAJA,EAKA,mBALA,EAMA,eANA,CAAA;;;;AAEA,UA+Da,4BA/Db,CAAA,OAAA,EAAA,iBAiEe,kBAjEf,EAAA,oBAAA,CAAA,CAAA;EACA,MAAA,EAmEM,OAnEN;EACA,OAAA,CAAA,EAmEQ,OAnER,CAmEgB,QAnEhB,CAAA;EACA,sBAAA,CAAA,EAmEuB,oBAnEvB;;;;AA4DJ;;;;;;;AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG,iBA7Ba,qBA6Bb,CAAA,OAAA,EAAA,iBA3BgB,kBA2BhB,EAAA,KAAA,EAAA,sBAzBqB,MAyBrB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,kBAxBiB,MAwBjB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,oBAAA,EAAA,yBAtBwB,MAsBxB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,4BArB2B,kBAqB3B,EAAA,4BApB2B,kBAoB3B,EAAA,eAAA,EAAA,iCAAA,SAlByC,iBAkBzC,EAAA,EAAA,yBAjBwB,MAiBxB,CAAA,MAAA,EAjBuC,6BAiBvC,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA,UAAA,EAfW,kBAeX,CAdC,OAcD,EAbC,QAaD,EAZC,KAYD,EAXC,aAWD,EAVC,SAUD,EATC,oBASD,EARC,gBAQD,EAPC,mBAOD,EANC,mBAMD,EALC,eAKD,EAJC,gBAID,CAAA,EAAA,iBAAA,EAFkB,kBAElB,EAAA,OAAA,EADQ,4BACR,CADqC,OACrC,EAD8C,QAC9C,EADwD,oBACxD,CAAA,CAAA,EAAA,0BAAA,CACD,kBADC,CACkB,qBADlB,CACwC,kBADxC,CAAA,EAC6D,gBAD7D,CAAA,EAED,KAFC,EAGD,aAHC,CAGa,aAHb,GAG6B,SAH7B,CAAA,EAID,mBAJC,EAKD,mBALC,EAMD,eANC,EAOD,QAPC,EAQD,gBARC,CAAA"}

package/dist/test/test.js.map

@@ -1 +1 @@
-{"version":3,"file":"test.js","names":["newBaseServices: ServiceConstructorFn<\n      TConfig,\n      TOptions,\n      TDeps,\n      TServiceDeps,\n      TPrivateServices,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServiceThisContext\n    >","testUtils: TestBaseServices<TDeps>"],"sources":["../../src/test/test.ts"],"sourcesContent":["import type { RequestThisContext } from \"../api/api\";\nimport type { AnyRouteOrFactory, FlattenRouteFactories } from \"../api/route\";\nimport type { FragnoPublicConfig } from \"../api/shared-types\";\nimport {\n  FragmentDefinitionBuilder,\n  type FragmentDefinition,\n  type ServiceConstructorFn,\n} from \"../api/fragment-definition-builder\";\nimport { instantiateFragment, type FragnoInstantiatedFragment } from \"../api/fragment-instantiator\";\nimport type { BoundServices } from \"../api/bind-services\";\n\n// Re-export for convenience\nexport type { RouteHandlerInputOptions } from \"../api/route-handler-input-options\";\nexport type { FragnoResponse } from \"../api/fragno-response\";\n\nexport type TestBaseServices<TDeps> = {\n  /**\n   * Access to fragment dependencies for testing purposes.\n   */\n  deps: TDeps;\n};\n\n/**\n * Extension function that adds test utilities to a fragment definition.\n * This adds a `test` service to base services with access to deps.\n *\n * @example\n * ```typescript\n * const definition = defineFragment(\"my-fragment\")\n *   .withDependencies(({ config }) => ({ client: createClient(config) }))\n *   .extend(withTestUtils())\n *   .build();\n *\n * const fragment = createFragmentForTest(definition, [], { config: {...} });\n * expect(fragment.services.test.deps.client).toBeDefined();\n * ```\n */\nexport function withTestUtils() {\n  return <\n    TConfig,\n    TOptions extends FragnoPublicConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext extends RequestThisContext,\n    THandlerThisContext extends RequestThisContext,\n    TRequestStorage,\n  >(\n    builder: FragmentDefinitionBuilder<\n      TConfig,\n      TOptions,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage\n    >,\n  ): FragmentDefinitionBuilder<\n    TConfig,\n    TOptions,\n    TDeps,\n    TBaseServices & TestBaseServices<TDeps>,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage\n  > => {\n    // Get the current base services factory\n    const currentBaseDef = builder.build();\n    const currentBaseServices = currentBaseDef.baseServices;\n\n    // Create new base services factory that merges test utilities\n    const newBaseServices: ServiceConstructorFn<\n      TConfig,\n      TOptions,\n      TDeps,\n      TServiceDeps,\n      TPrivateServices,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServiceThisContext\n    > = (context) => {\n      // Call existing base services if they exist\n      const existingServices = currentBaseServices\n        ? currentBaseServices(context)\n        : ({} as TBaseServices);\n\n      // Add test utilities\n      const testUtils: TestBaseServices<TDeps> = {\n        deps: context.deps,\n      };\n\n      return {\n        ...existingServices,\n        ...testUtils,\n      } as TBaseServices & TestBaseServices<TDeps>;\n    };\n\n    // Create new builder with updated base services\n    return new FragmentDefinitionBuilder<\n      TConfig,\n      TOptions,\n      TDeps,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage\n    >(builder.name, {\n      dependencies: currentBaseDef.dependencies,\n      baseServices: newBaseServices,\n      namedServices: currentBaseDef.namedServices,\n      privateServices: currentBaseDef.privateServices,\n      serviceDependencies: currentBaseDef.serviceDependencies,\n      createRequestStorage: currentBaseDef.createRequestStorage,\n      createThisContext: currentBaseDef.createThisContext,\n    });\n  };\n}\n\n/**\n * Options for creating a test fragment with the new architecture\n */\nexport interface CreateFragmentForTestOptions<\n  TConfig,\n  TOptions extends FragnoPublicConfig,\n  TServiceDependencies,\n> {\n  config: TConfig;\n  options?: Partial<TOptions>;\n  serviceImplementations?: TServiceDependencies;\n}\n\n/**\n * Create a fragment instance for testing with optional service dependency overrides.\n * This uses the new fragment definition and instantiation architecture.\n *\n * **Important:** Use `.extend(withTestUtils())` before `.build()` to expose deps via `services.test.deps`.\n *\n * Returns an instantiated fragment with:\n * - `services` - Services (base + named) from the fragment definition\n * - `services.test.deps` - Dependencies (only if you used .extend(withTestUtils()))\n * - `callRoute()` - Type-safe method to call routes directly\n * - `handler()` - Request handler for integration\n * - `inContext()` - Run code within request context\n *\n * @param definition - The fragment definition from builder.build()\n * @param routesOrFactories - Route configurations or route factories\n * @param options - Configuration and optional overrides\n * @returns An instantiated fragment ready for testing\n *\n * @example\n * ```typescript\n * const definition = defineFragment<{ apiKey: string }>(\"test\")\n *   .withDependencies(({ config }) => ({ client: createClient(config.apiKey) }))\n *   .providesService(\"api\", ({ deps }) => ({ call: () => deps.client.call() }))\n *   .extend(withTestUtils())  // <- Add test utilities\n *   .build();\n *\n * const fragment = createFragmentForTest(\n *   definition,\n *   [route1, route2],\n *   {\n *     config: { apiKey: \"test-key\" },\n *     options: { mountRoute: \"/api/test\" }\n *   }\n * );\n *\n * // Access deps via test utilities\n * expect(fragment.services.test.deps.client).toBeDefined();\n * expect(fragment.services.api.call()).toBeDefined();\n *\n * // Call routes directly by method and path\n * const response = await fragment.callRoute(\"POST\", \"/login\", {\n *   body: { username: \"test\", password: \"test123\" }\n * });\n *\n * if (response.type === 'json') {\n *   expect(response.data).toEqual({...});\n * }\n * ```\n */\nexport function createFragmentForTest<\n  TConfig,\n  TOptions extends FragnoPublicConfig,\n  TDeps,\n  TBaseServices extends Record<string, unknown>,\n  TServices extends Record<string, unknown>,\n  TServiceDependencies,\n  TPrivateServices extends Record<string, unknown>,\n  TServiceThisContext extends RequestThisContext,\n  THandlerThisContext extends RequestThisContext,\n  TRequestStorage,\n  const TRoutesOrFactories extends readonly AnyRouteOrFactory[],\n>(\n  definition: FragmentDefinition<\n    TConfig,\n    TOptions,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage\n  >,\n  routesOrFactories: TRoutesOrFactories,\n  options: CreateFragmentForTestOptions<TConfig, TOptions, TServiceDependencies>,\n): FragnoInstantiatedFragment<\n  FlattenRouteFactories<TRoutesOrFactories>,\n  TDeps,\n  BoundServices<TBaseServices & TServices>,\n  TServiceThisContext,\n  THandlerThisContext,\n  TRequestStorage\n> {\n  const { config, options: fragmentOptions = {} as TOptions, serviceImplementations } = options;\n\n  // Use default mountRoute for testing if not provided\n  const fullOptions = {\n    mountRoute: \"/api/test\",\n    ...fragmentOptions,\n  } as TOptions;\n\n  // Instantiate and return the fragment directly\n  return instantiateFragment(\n    definition,\n    config,\n    routesOrFactories,\n    fullOptions,\n    serviceImplementations,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,gBAAgB;AAC9B,SAYE,YAuBG;EAEH,MAAM,iBAAiB,QAAQ,OAAO;EACtC,MAAM,sBAAsB,eAAe;EAG3C,MAAMA,mBAQD,YAAY;GAEf,MAAM,mBAAmB,sBACrB,oBAAoB,QAAQ,GAC3B,EAAE;GAGP,MAAMC,YAAqC,EACzC,MAAM,QAAQ,MACf;AAED,UAAO;IACL,GAAG;IACH,GAAG;IACJ;;AAIH,SAAO,IAAI,0BAWT,QAAQ,MAAM;GACd,cAAc,eAAe;GAC7B,cAAc;GACd,eAAe,eAAe;GAC9B,iBAAiB,eAAe;GAChC,qBAAqB,eAAe;GACpC,sBAAsB,eAAe;GACrC,mBAAmB,eAAe;GACnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEN,SAAgB,sBAad,YAYA,mBACA,SAQA;CACA,MAAM,EAAE,QAAQ,SAAS,kBAAkB,EAAE,EAAc,2BAA2B;AAStF,QAAO,oBACL,YACA,QACA,mBATkB;EAClB,YAAY;EACZ,GAAG;EACJ,EAQC,uBACD"}
+{"version":3,"file":"test.js","names":["newBaseServices: ServiceConstructorFn<\n      TConfig,\n      TOptions,\n      TDeps,\n      TServiceDeps,\n      TPrivateServices,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServiceThisContext\n    >","testUtils: TestBaseServices<TDeps>"],"sources":["../../src/test/test.ts"],"sourcesContent":["import type { RequestThisContext } from \"../api/api\";\nimport type { AnyRouteOrFactory, FlattenRouteFactories } from \"../api/route\";\nimport type { FragnoPublicConfig } from \"../api/shared-types\";\nimport {\n  FragmentDefinitionBuilder,\n  type FragmentDefinition,\n  type ServiceConstructorFn,\n} from \"../api/fragment-definition-builder\";\nimport {\n  instantiateFragment,\n  type AnyFragnoInstantiatedFragment,\n  type FragnoInstantiatedFragment,\n  type RoutesWithInternal,\n} from \"../api/fragment-instantiator\";\nimport type { BoundServices } from \"../api/bind-services\";\n\n// Re-export for convenience\nexport type { RouteHandlerInputOptions } from \"../api/route-handler-input-options\";\nexport type { FragnoResponse } from \"../api/fragno-response\";\n\nexport type TestBaseServices<TDeps> = {\n  /**\n   * Access to fragment dependencies for testing purposes.\n   */\n  deps: TDeps;\n};\n\n/**\n * Extension function that adds test utilities to a fragment definition.\n * This adds a `test` service to base services with access to deps.\n *\n * @example\n * ```typescript\n * const definition = defineFragment(\"my-fragment\")\n *   .withDependencies(({ config }) => ({ client: createClient(config) }))\n *   .extend(withTestUtils())\n *   .build();\n *\n * const fragment = createFragmentForTest(definition, [], { config: {...} });\n * expect(fragment.services.test.deps.client).toBeDefined();\n * ```\n */\nexport function withTestUtils() {\n  return <\n    TConfig,\n    TOptions extends FragnoPublicConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext extends RequestThisContext,\n    THandlerThisContext extends RequestThisContext,\n    TRequestStorage,\n  >(\n    builder: FragmentDefinitionBuilder<\n      TConfig,\n      TOptions,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage\n    >,\n  ): FragmentDefinitionBuilder<\n    TConfig,\n    TOptions,\n    TDeps,\n    TBaseServices & TestBaseServices<TDeps>,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage\n  > => {\n    // Get the current base services factory\n    const currentBaseDef = builder.build();\n    const currentBaseServices = currentBaseDef.baseServices;\n\n    // Create new base services factory that merges test utilities\n    const newBaseServices: ServiceConstructorFn<\n      TConfig,\n      TOptions,\n      TDeps,\n      TServiceDeps,\n      TPrivateServices,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServiceThisContext\n    > = (context) => {\n      // Call existing base services if they exist\n      const existingServices = currentBaseServices\n        ? currentBaseServices(context)\n        : ({} as TBaseServices);\n\n      // Add test utilities\n      const testUtils: TestBaseServices<TDeps> = {\n        deps: context.deps,\n      };\n\n      return {\n        ...existingServices,\n        ...testUtils,\n      } as TBaseServices & TestBaseServices<TDeps>;\n    };\n\n    // Create new builder with updated base services\n    return new FragmentDefinitionBuilder<\n      TConfig,\n      TOptions,\n      TDeps,\n      TBaseServices & TestBaseServices<TDeps>,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage\n    >(builder.name, {\n      dependencies: currentBaseDef.dependencies,\n      baseServices: newBaseServices,\n      namedServices: currentBaseDef.namedServices,\n      privateServices: currentBaseDef.privateServices,\n      serviceDependencies: currentBaseDef.serviceDependencies,\n      createRequestStorage: currentBaseDef.createRequestStorage,\n      createThisContext: currentBaseDef.createThisContext,\n    });\n  };\n}\n\n/**\n * Options for creating a test fragment with the new architecture\n */\nexport interface CreateFragmentForTestOptions<\n  TConfig,\n  TOptions extends FragnoPublicConfig,\n  TServiceDependencies,\n> {\n  config: TConfig;\n  options?: Partial<TOptions>;\n  serviceImplementations?: TServiceDependencies;\n}\n\n/**\n * Create a fragment instance for testing with optional service dependency overrides.\n * This uses the new fragment definition and instantiation architecture.\n *\n * **Important:** Use `.extend(withTestUtils())` before `.build()` to expose deps via `services.test.deps`.\n *\n * Returns an instantiated fragment with:\n * - `services` - Services (base + named) from the fragment definition\n * - `services.test.deps` - Dependencies (only if you used .extend(withTestUtils()))\n * - `callRoute()` - Type-safe method to call routes directly\n * - `handler()` - Request handler for integration\n * - `inContext()` - Run code within request context\n *\n * @param definition - The fragment definition from builder.build()\n * @param routesOrFactories - Route configurations or route factories\n * @param options - Configuration and optional overrides\n * @returns An instantiated fragment ready for testing\n *\n * @example\n * ```typescript\n * const definition = defineFragment<{ apiKey: string }>(\"test\")\n *   .withDependencies(({ config }) => ({ client: createClient(config.apiKey) }))\n *   .providesService(\"api\", ({ deps }) => ({ call: () => deps.client.call() }))\n *   .extend(withTestUtils())  // <- Add test utilities\n *   .build();\n *\n * const fragment = createFragmentForTest(\n *   definition,\n *   [route1, route2],\n *   {\n *     config: { apiKey: \"test-key\" },\n *     options: { mountRoute: \"/api/test\" }\n *   }\n * );\n *\n * // Access deps via test utilities\n * expect(fragment.services.test.deps.client).toBeDefined();\n * expect(fragment.services.api.call()).toBeDefined();\n *\n * // Call routes directly by method and path\n * const response = await fragment.callRoute(\"POST\", \"/login\", {\n *   body: { username: \"test\", password: \"test123\" }\n * });\n *\n * if (response.type === 'json') {\n *   expect(response.data).toEqual({...});\n * }\n * ```\n */\nexport function createFragmentForTest<\n  TConfig,\n  TOptions extends FragnoPublicConfig,\n  TDeps,\n  TBaseServices extends Record<string, unknown>,\n  TServices extends Record<string, unknown>,\n  TServiceDependencies,\n  TPrivateServices extends Record<string, unknown>,\n  TServiceThisContext extends RequestThisContext,\n  THandlerThisContext extends RequestThisContext,\n  TRequestStorage,\n  const TRoutesOrFactories extends readonly AnyRouteOrFactory[],\n  TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {},\n>(\n  definition: FragmentDefinition<\n    TConfig,\n    TOptions,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage,\n    TLinkedFragments\n  >,\n  routesOrFactories: TRoutesOrFactories,\n  options: CreateFragmentForTestOptions<TConfig, TOptions, TServiceDependencies>,\n): FragnoInstantiatedFragment<\n  RoutesWithInternal<FlattenRouteFactories<TRoutesOrFactories>, TLinkedFragments>,\n  TDeps,\n  BoundServices<TBaseServices & TServices>,\n  TServiceThisContext,\n  THandlerThisContext,\n  TRequestStorage,\n  TOptions,\n  TLinkedFragments\n> {\n  const { config, options: fragmentOptions = {} as TOptions, serviceImplementations } = options;\n\n  // Use default mountRoute for testing if not provided\n  const fullOptions = {\n    mountRoute: \"/api/test\",\n    ...fragmentOptions,\n  } as TOptions;\n\n  // Instantiate and return the fragment directly\n  return instantiateFragment(\n    definition,\n    config,\n    routesOrFactories,\n    fullOptions,\n    serviceImplementations,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,gBAAgB;AAC9B,SAYE,YAuBG;EAEH,MAAM,iBAAiB,QAAQ,OAAO;EACtC,MAAM,sBAAsB,eAAe;EAG3C,MAAMA,mBAQD,YAAY;GAEf,MAAM,mBAAmB,sBACrB,oBAAoB,QAAQ,GAC3B,EAAE;GAGP,MAAMC,YAAqC,EACzC,MAAM,QAAQ,MACf;AAED,UAAO;IACL,GAAG;IACH,GAAG;IACJ;;AAIH,SAAO,IAAI,0BAWT,QAAQ,MAAM;GACd,cAAc,eAAe;GAC7B,cAAc;GACd,eAAe,eAAe;GAC9B,iBAAiB,eAAe;GAChC,qBAAqB,eAAe;GACpC,sBAAsB,eAAe;GACrC,mBAAmB,eAAe;GACnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEN,SAAgB,sBAcd,YAaA,mBACA,SAUA;CACA,MAAM,EAAE,QAAQ,SAAS,kBAAkB,EAAE,EAAc,2BAA2B;AAStF,QAAO,oBACL,YACA,QACA,mBATkB;EAClB,YAAY;EACZ,GAAG;EACJ,EAQC,uBACD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragno-dev/core",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "exports": {
     ".": {
       "workerd": {
@@ -40,6 +40,11 @@
       "types": "./dist/api/request-context-storage.d.ts",
       "default": "./dist/api/request-context-storage.js"
     },
+    "./internal/trace-context": {
+      "development": "./src/internal/trace-context.ts",
+      "types": "./dist/internal/trace-context.d.ts",
+      "default": "./dist/internal/trace-context.js"
+    },
     "./internal/symbols": {
       "development": "./src/internal/symbols.ts",
       "types": "./dist/internal/symbols.d.ts",
@@ -88,29 +93,30 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
+    "@paralleldrive/cuid2": "^2.3.1",
     "@nanostores/query": "^0.3.4",
     "@nanostores/solid": "^1.1.1",
-    "@standard-schema/spec": "^1.0.0",
-    "nanostores": "^1.0.1",
-    "rou3": "^0.7.3"
+    "@standard-schema/spec": "^1.1.0",
+    "nanostores": "^1.1.0",
+    "rou3": "^0.7.12"
   },
   "devDependencies": {
-    "@sveltejs/vite-plugin-svelte": "^6.2.0",
-    "@testing-library/react": "^16.3.0",
-    "@testing-library/svelte": "^5.2.8",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/svelte": "^5.3.1",
     "@testing-library/vue": "^8.1.0",
-    "@types/node": "^22",
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
+    "@types/node": "^22.19.7",
+    "@types/react": "^19.2.8",
+    "@types/react-dom": "^19.2.3",
     "@vitest/coverage-istanbul": "^3.2.4",
-    "happy-dom": "^20.0.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "svelte": "^5.1.0",
-    "solid-js": "^1.9.3",
+    "happy-dom": "^20.3.3",
+    "react": "^19.0.3",
+    "react-dom": "^19.0.3",
+    "solid-js": "^1.9.10",
+    "svelte": "^5.47.0",
     "vitest": "^3.2.4",
-    "vue": "^3",
-    "zod": "^4.0.5",
+    "vue": "^3.5.27",
+    "zod": "^4.3.5",
     "@fragno-private/typescript-config": "0.0.1",
     "@fragno-private/vitest-config": "0.0.0"
   },

package/src/api/api.ts

@@ -27,6 +27,17 @@ export type ValidPath<T extends string = string> = T extends `/${infer Rest}`
 
 export interface RequestThisContext {}
 
+/**
+ * Content types that can be accepted by a route.
+ *
+ * - `"application/json"` (default): JSON request body, validated against inputSchema
+ * - `"multipart/form-data"`: FormData request body (file uploads), no schema validation
+ */
+export type RouteContentType =
+  | "application/json"
+  | "multipart/form-data"
+  | "application/octet-stream";
+
 export interface FragnoRouteConfig<
   TMethod extends HTTPMethod,
   TPath extends string,
@@ -38,6 +49,17 @@ export interface FragnoRouteConfig<
 > {
   method: TMethod;
   path: TPath;
+  /**
+   * The expected content type for this route's request body.
+   *
+   * - `"application/json"` (default): Expects JSON body, will be validated against inputSchema
+   * - `"multipart/form-data"`: Expects FormData body (for file uploads), use `ctx.formData()` in handler
+   *
+   * The server will reject requests with mismatched Content-Type headers.
+   *
+   * @default "application/json"
+   */
+  contentType?: RouteContentType;
   inputSchema?: TInputSchema;
   outputSchema?: TOutputSchema;
   errorCodes?: readonly TErrorCode[];

package/src/api/fragment-definition-builder.ts

@@ -24,12 +24,12 @@ export type LinkedFragmentCallback<
   TConfig,
   TOptions extends FragnoPublicConfig,
   TServiceDependencies,
+  TFragment extends AnyFragnoInstantiatedFragment = AnyFragnoInstantiatedFragment,
 > = (context: {
   config: TConfig;
   options: TOptions;
   serviceDependencies?: TServiceDependencies;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-}) => FragnoInstantiatedFragment<any, any, any, any, any, any, any>;
+}) => TFragment;
 
 /**
  * Extract the services type from a FragnoInstantiatedFragment
@@ -223,12 +223,27 @@ export interface FragmentDefinition<
     deps: TDeps;
   }) => RequestContextStorage<TRequestStorage>;
 
+  /**
+   * Optional factory for internal data attached to fragment.$internal.
+   */
+  internalDataFactory?: (context: {
+    config: TConfig;
+    options: TOptions;
+    deps: TDeps;
+    linkedFragments: TLinkedFragments;
+  }) => Record<string, unknown> | void;
+
   /**
    * 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>;
+    [K in keyof TLinkedFragments]: LinkedFragmentCallback<
+      TConfig,
+      TOptions,
+      TServiceDependencies,
+      TLinkedFragments[K]
+    >;
   };
 
   $serviceThisContext?: TServiceThisContext;
@@ -307,7 +322,12 @@ export class FragmentDefinitionBuilder<
     deps: TDeps;
   }) => RequestContextStorage<TRequestStorage>;
   #linkedFragments?: {
-    [K in keyof TLinkedFragments]: LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies>;
+    [K in keyof TLinkedFragments]: LinkedFragmentCallback<
+      TConfig,
+      TOptions,
+      TServiceDependencies,
+      TLinkedFragments[K]
+    >;
   };
 
   constructor(
@@ -368,7 +388,8 @@ export class FragmentDefinitionBuilder<
         [K in keyof TLinkedFragments]: LinkedFragmentCallback<
           TConfig,
           TOptions,
-          TServiceDependencies
+          TServiceDependencies,
+          TLinkedFragments[K]
         >;
       };
     },
@@ -966,15 +987,13 @@ export class FragmentDefinitionBuilder<
 
   /**
    * 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.
+   * Linked fragments share the same config/options as the parent and their services
+   * are exposed as private services. Routes are not exposed by default, but the
+   * instantiator may mount internal linked fragment routes under an internal prefix.
    */
-  withLinkedFragment<
-    const TName extends string,
-    TCallback extends LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies>,
-  >(
+  withLinkedFragment<const TName extends string, TFragment extends AnyFragnoInstantiatedFragment>(
     name: TName,
-    callback: TCallback,
+    callback: LinkedFragmentCallback<TConfig, TOptions, TServiceDependencies, TFragment>,
   ): FragmentDefinitionBuilder<
     TConfig,
     TOptions,
@@ -982,18 +1001,18 @@ export class FragmentDefinitionBuilder<
     TBaseServices,
     TServices,
     TServiceDependencies,
-    TPrivateServices & ExtractLinkedServices<TCallback>,
+    TPrivateServices & ExtractLinkedServices<() => TFragment>,
     TServiceThisContext,
     THandlerThisContext,
     TRequestStorage,
-    TLinkedFragments & { [K in TName]: ReturnType<TCallback> }
+    TLinkedFragments & { [K in TName]: TFragment }
   > {
     const newLinkedFragments = {
       ...this.#linkedFragments,
       [name]: callback,
     };
 
-    // Cast is safe: We're declaring that the returned builder has TPrivateServices & ExtractLinkedServices<TCallback>,
+    // Cast is safe: We're declaring that the returned builder has TPrivateServices & ExtractLinkedServices<TFragment>,
     // even though the runtime privateServices hasn't changed yet. The linked fragment services will be
     // merged into privateServices at instantiation time by the instantiator.
     return new FragmentDefinitionBuilder(this.#name, {
@@ -1013,11 +1032,11 @@ export class FragmentDefinitionBuilder<
       TBaseServices,
       TServices,
       TServiceDependencies,
-      TPrivateServices & ExtractLinkedServices<TCallback>,
+      TPrivateServices & ExtractLinkedServices<() => TFragment>,
       TServiceThisContext,
       THandlerThisContext,
       TRequestStorage,
-      TLinkedFragments & { [K in TName]: ReturnType<TCallback> }
+      TLinkedFragments & { [K in TName]: TFragment }
     >;
   }