Address review: keep zero-arg public factory calls working

Before PR #19 the public Container.factories map held memoized factories
that carried a `thisArg`, so calling `c.factories.svc()` directly (without
going through `get()`) would still resolve dependencies through the
container. After the chain switch the factory body uses call-site `this`,
which means a direct invocation makes `this` the factories map itself —
`this.get(...)` then throws for any service with dependencies.

Fix in `buildFlatFactories`: when materializing the public flat view, wrap
each factory in a tiny forwarder that calls the underlying memoized
factory with the container as `this`. Memo state stays in the underlying
factory's closure (so memoization is preserved and shared across the
chain), and both `get()` and a direct `c.factories[token]()` now route
through the same container — matching the old public contract.

Adds a test that exercises a dependent service through the public
factories map. 97/97 tests pass, 100% coverage.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kburov-sc

src/Container.ts

@@ -300,8 +300,18 @@ export class Container<Services = {}> {
 
   private buildFlatFactories(): Factories<Services> {
     const flat = Object.create(null) as Factories<Services>;
+    const self = this;
     chainedForEach<Memoized<() => unknown>>(this.factoriesChain, (k, v) => {
-      (flat as Record<string, Memoized<() => unknown>>)[k] = v;
+      // Wrap each factory so direct invocation via `c.factories[token]()` resolves the
+      // service through THIS container, not through the factories map (which would
+      // otherwise be `this` inside the underlying memoized closure and break any
+      // factory that calls `this.get(...)`). Forwarding to `v.call(self)` preserves
+      // memoization — memo state lives in `v`'s closure and is shared across the chain
+      // — and keeps `get()`'s call-site `this` semantics intact since `get()` and a
+      // direct call both end up routing through `self`.
+      const bound = (() => v.call(self)) as Memoized<() => unknown>;
+      bound.delegate = v.delegate;
+      (flat as Record<string, Memoized<() => unknown>>)[k] = bound;
     });
     return flat;
   }

src/__tests__/Container.spec.ts

@@ -576,6 +576,15 @@ describe("Container", () => {
   });
 
   describe("when accessing factories", () => {
+    test("direct invocation of factories[token] works for services with dependencies", () => {
+      // Pre-PR-#19, memoized factories carried `thisArg`, so calling a factory directly
+      // (bypassing `get()`) still resolved its dependencies through the container.
+      // Consumers using the public `factories` map should not see `this.get is not a
+      // function` from a dependent service.
+      const c = Container.providesValue("dep", 42).provides("svc", ["dep"] as const, (d: number) => d * 2);
+      expect(c.factories.svc()).toBe(84);
+    });
+
     test("Object.keys returns every registered token regardless of chain depth", () => {
       // Public `factories` exposes a flat own-property view; internal chain extension via
       // Object.create stays an implementation detail.