bunja 3.0.0-alpha.3 → 3.0.0-alpha.4

package/bunja.ts

@@ -94,7 +94,6 @@ export type Dep<T> = Bunja<T, any> | Scope<T>;
 
 type AnyBunja = Bunja<any, any>;
 type ScopeInstanceMap = Map<Scope<unknown>, ScopeInstance>;
-type BunjaDependencyEdge = "required" | "optional";
 
 interface BunjaFrame {
   use: BunjaUseFn;
@@ -251,11 +250,8 @@ function getBoundScopeSet(
 function getScopeInstances(
   scopes: Scope<unknown>[],
   scopeInstanceMap: ScopeInstanceMap,
-  excludeScopes: Set<Scope<unknown>> = new Set(),
 ): ScopeInstance[] {
-  return scopes
-    .filter((scope) => !excludeScopes.has(scope))
-    .map((scope) => scopeInstanceMap.get(scope)!);
+  return scopes.map((scope) => scopeInstanceMap.get(scope)!);
 }
 
 function dedupeScopeInstances(
@@ -331,6 +327,7 @@ export class BunjaStore {
       readScope,
       new Set(),
       bunjaRef.seed,
+      true,
     );
     const result: BunjaStoreGetResult<T> = {
       value: resolved.value,
@@ -366,6 +363,7 @@ export class BunjaStore {
     readScope: ReadScope,
     inProgressBunjas: Set<AnyBunja>,
     seed: Seed = bunjaRef.bunja.defaultSeed,
+    includeBoundScopeDeps: boolean = false,
   ): ResolvedBunja<T> {
     const { bunja } = bunjaRef;
     if (inProgressBunjas.has(bunja)) {
@@ -382,6 +380,7 @@ export class BunjaStore {
           resolvedReadScope,
           inProgressBunjas,
           seed,
+          includeBoundScopeDeps,
         );
       }
       const scopeInstanceMap = this.#resolveScopeInstanceMap(
@@ -394,9 +393,10 @@ export class BunjaStore {
         scopeInstanceMap,
       );
       const directDeps = getScopeInstances(
-        bunja.requiredScopes,
+        includeBoundScopeDeps
+          ? bunja.requiredScopes
+          : bunja.requiredScopes.filter((scope) => !boundScopes.has(scope)),
         scopeInstanceMap,
-        boundScopes,
       );
       const baseId = bunja.calcBaseInstanceId(scopeInstanceMap);
       const bucket = this.#bunjaBuckets.get(baseId);
@@ -433,6 +433,7 @@ export class BunjaStore {
         resolvedReadScope,
         inProgressBunjas,
         seed,
+        includeBoundScopeDeps,
         scopeInstanceMap,
       );
     } finally {
@@ -444,6 +445,7 @@ export class BunjaStore {
     readScope: ReadScope,
     inProgressBunjas: Set<AnyBunja>,
     seed: Seed,
+    includeBoundScopeDeps: boolean,
     initialScopeInstanceMap: ScopeInstanceMap = new Map(),
   ): ResolvedBunja<T> {
     const { bunja } = bunjaRef;
@@ -475,9 +477,10 @@ export class BunjaStore {
           frame.scopeInstanceMap,
         );
         const directDeps = getScopeInstances(
-          bunja.requiredScopes,
+          includeBoundScopeDeps
+            ? bunja.requiredScopes
+            : bunja.requiredScopes.filter((scope) => !boundScopes.has(scope)),
           frame.scopeInstanceMap,
-          boundScopes,
         );
         const baseId = bunja.calcBaseInstanceId(frame.scopeInstanceMap);
         const id = bunja.calcInstanceId(
@@ -560,11 +563,10 @@ export class BunjaStore {
           return this.#useScopeInFrame(frame, dep as Scope<unknown>);
         }
         if (dep instanceof Bunja || isBunjaRef(dep)) {
-          return this.#useBunjaDependencyInFrame(
-            frame,
-            normalizeBunjaRuntimeRef(dep, scopeValuePairs),
-            "required",
-          );
+          const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
+          const graphRef = toBunjaGraphRef(bunjaRef);
+          currentBunja.addRequiredBunjaRef(graphRef);
+          return this.#useBunjaDependencyInFrame(frame, bunjaRef);
         }
         throw new Error("`bunja.use` can only be used with Bunja or Scope.");
       }) as BunjaUseFn,
@@ -573,18 +575,15 @@ export class BunjaStore {
           throw new Error("`bunja.will` can only be used with Bunja.");
         }
         const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-        currentBunja.addOptionalBunjaRef(toBunjaGraphRef(bunjaRef));
+        const graphRef = toBunjaGraphRef(bunjaRef);
+        currentBunja.addOptionalBunjaRef(graphRef);
         return () => {
           if (frameStack[frameStack.length - 1] !== frame) {
             throw new Error(
               "A thunk returned by `bunja.will` can only be called inside the same bunja init function.",
             );
           }
-          return this.#useBunjaDependencyInFrame(
-            frame,
-            bunjaRef,
-            "optional",
-          );
+          return this.#useBunjaDependencyInFrame(frame, bunjaRef);
         };
       }) as BunjaWillFn,
       effect: ((callback: BunjaEffectCallback) => {
@@ -615,14 +614,8 @@ export class BunjaStore {
   #useBunjaDependencyInFrame<T, Seed>(
     frame: BunjaInitFrame,
     bunjaRef: NormalizedBunjaRuntimeRef<T, Seed>,
-    edge: BunjaDependencyEdge,
   ): T {
     const graphRef = toBunjaGraphRef(bunjaRef);
-    if (edge === "optional" || graphRef.scopeValuePairs.length > 0) {
-      frame.currentBunja.addOptionalBunjaRef(graphRef);
-    } else if (edge === "required") {
-      frame.currentBunja.addRequiredBunjaRef(graphRef);
-    }
     const resolved = this.#resolveBunjaRef(
       graphRef,
       frame.readScope,
@@ -725,11 +718,14 @@ export class BunjaStore {
           return readScope(dep as Scope<unknown>);
         }
         if (dep instanceof Bunja || isBunjaRef(dep)) {
-          const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-          return this.#prebakeBunjaDependencyInFrame(
-            frame,
-            toBunjaGraphRef(bunjaRef),
-            "required",
+          const bunjaRef = toBunjaGraphRef(
+            normalizeBunjaRuntimeRef(dep, scopeValuePairs),
+          );
+          currentBunja.addRequiredBunjaRef(bunjaRef);
+          return this.#prebakeBunjaRef(
+            bunjaRef,
+            readScope,
+            prebakeContext,
           );
         }
         throw new Error("`bunja.use` can only be used with Bunja or Scope.");
@@ -760,22 +756,6 @@ export class BunjaStore {
     } satisfies BunjaPrebakeFrame;
     return frame;
   }
-  #prebakeBunjaDependencyInFrame<T, Seed>(
-    frame: BunjaPrebakeFrame,
-    bunjaRef: NormalizedBunjaRef<T, Seed>,
-    edge: BunjaDependencyEdge,
-  ): T {
-    if (edge === "optional" || bunjaRef.scopeValuePairs.length > 0) {
-      frame.currentBunja.addOptionalBunjaRef(bunjaRef);
-    } else if (edge === "required") {
-      frame.currentBunja.addRequiredBunjaRef(bunjaRef);
-    }
-    return this.#prebakeBunjaRef(
-      bunjaRef,
-      frame.readScope,
-      frame.prebakeContext,
-    );
-  }
   #resolveScopeInstanceMap(
     bunja: AnyBunja,
     readScope: ReadScope,
@@ -984,8 +964,11 @@ export class Bunja<T, Seed = NoSeed> {
     const requiredBunjas = this.requiredBunjas;
     const expandedRequiredBunjas = toposortRequiredBunjas(requiredBunjas);
     const requiredScopeSet = new Set<Scope<unknown>>();
-    for (const bunja of expandedRequiredBunjas) {
-      for (const scope of bunja.requiredScopes) requiredScopeSet.add(scope);
+    for (const ref of requiredBunjaRefs) {
+      const boundScopes = getBoundScopeSet(ref.scopeValuePairs);
+      for (const scope of ref.bunja.requiredScopes) {
+        if (!boundScopes.has(scope)) requiredScopeSet.add(scope);
+      }
     }
     for (const scope of scopes) requiredScopeSet.add(scope);
     const requiredScopes = Array.from(requiredScopeSet);

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@disjukr/bunja",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "license": "Zlib",
   "exports": {
     ".": "./bunja.ts",

package/dist/{bunja-BJSmIdkQ.cjs → bunja-C_hneAUK.cjs}

@@ -73,8 +73,8 @@ function isBunjaRef(value) {
 function getBoundScopeSet(scopeValuePairs) {
 	return new Set(scopeValuePairs.map(([scope]) => scope));
 }
-function getScopeInstances(scopes, scopeInstanceMap, excludeScopes = /* @__PURE__ */ new Set()) {
-	return scopes.filter((scope) => !excludeScopes.has(scope)).map((scope) => scopeInstanceMap.get(scope));
+function getScopeInstances(scopes, scopeInstanceMap) {
+	return scopes.map((scope) => scopeInstanceMap.get(scope));
 }
 function dedupeScopeInstances(scopeInstances) {
 	const seen = /* @__PURE__ */ new Set();
@@ -127,7 +127,7 @@ var BunjaStore = class BunjaStore {
 	}
 	get(bunjaOrRef, readScope) {
 		const bunjaRef = normalizeBunjaRuntimeRef(bunjaOrRef);
-		const resolved = this.#resolveBunjaRef(toBunjaGraphRef(bunjaRef), readScope, /* @__PURE__ */ new Set(), bunjaRef.seed);
+		const resolved = this.#resolveBunjaRef(toBunjaGraphRef(bunjaRef), readScope, /* @__PURE__ */ new Set(), bunjaRef.seed, true);
 		const result = {
 			value: resolved.value,
 			mount: resolved.mount,
@@ -150,17 +150,17 @@ var BunjaStore = class BunjaStore {
 			requiredScopes: bunjaRef.bunja.requiredScopes
 		};
 	}
-	#resolveBunjaRef(bunjaRef, readScope, inProgressBunjas, seed = bunjaRef.bunja.defaultSeed) {
+	#resolveBunjaRef(bunjaRef, readScope, inProgressBunjas, seed = bunjaRef.bunja.defaultSeed, includeBoundScopeDeps = false) {
 		const { bunja: bunja$1 } = bunjaRef;
 		if (inProgressBunjas.has(bunja$1)) throw new Error("Circular bunja dependency detected.");
 		const resolvedReadScope = bunjaRef.scopeValuePairs.length > 0 ? createReadScopeFn(bunjaRef.scopeValuePairs, readScope) : readScope;
 		inProgressBunjas.add(bunja$1);
 		try {
-			if (!bunja$1.baked) return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed);
+			if (!bunja$1.baked) return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, includeBoundScopeDeps);
 			const scopeInstanceMap = this.#resolveScopeInstanceMap(bunja$1, resolvedReadScope);
 			const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
 			const scopeInstances = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap);
-			const directDeps = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap, boundScopes);
+			const directDeps = getScopeInstances(includeBoundScopeDeps ? bunja$1.requiredScopes : bunja$1.requiredScopes.filter((scope) => !boundScopes.has(scope)), scopeInstanceMap);
 			const baseId = bunja$1.calcBaseInstanceId(scopeInstanceMap);
 			const bucket = this.#bunjaBuckets.get(baseId);
 			if (bucket) for (const candidateId of Array.from(bucket)) {
@@ -175,12 +175,12 @@ var BunjaStore = class BunjaStore {
 				if (!instance) continue;
 				return this.#toResolvedBunja(instance, scopeInstances, directDeps, activeDeps.deps);
 			}
-			return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, scopeInstanceMap);
+			return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, includeBoundScopeDeps, scopeInstanceMap);
 		} finally {
 			inProgressBunjas.delete(bunja$1);
 		}
 	}
-	#createResolvedBunja(bunjaRef, readScope, inProgressBunjas, seed, initialScopeInstanceMap = /* @__PURE__ */ new Map()) {
+	#createResolvedBunja(bunjaRef, readScope, inProgressBunjas, seed, includeBoundScopeDeps, initialScopeInstanceMap = /* @__PURE__ */ new Map()) {
 		const { bunja: bunja$1 } = bunjaRef;
 		return this.wrapInstance((dispose) => {
 			let instanceCreated = false;
@@ -197,7 +197,7 @@ var BunjaStore = class BunjaStore {
 				this.#ensureRequiredScopeInstances(bunja$1, frame.scopeInstanceMap, readScope);
 				const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
 				const scopeInstances = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap);
-				const directDeps = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap, boundScopes);
+				const directDeps = getScopeInstances(includeBoundScopeDeps ? bunja$1.requiredScopes : bunja$1.requiredScopes.filter((scope) => !boundScopes.has(scope)), frame.scopeInstanceMap);
 				const baseId = bunja$1.calcBaseInstanceId(frame.scopeInstanceMap);
 				const id = bunja$1.calcInstanceId(frame.scopeInstanceMap, frame.activeDependencyIds);
 				const existing = this.#bunjas[id];
@@ -242,16 +242,22 @@ var BunjaStore = class BunjaStore {
 			activeDependencyDeps: [],
 			use: ((dep, scopeValuePairs) => {
 				if (dep instanceof Scope) return this.#useScopeInFrame(frame, dep);
-				if (dep instanceof Bunja || isBunjaRef(dep)) return this.#useBunjaDependencyInFrame(frame, normalizeBunjaRuntimeRef(dep, scopeValuePairs), "required");
+				if (dep instanceof Bunja || isBunjaRef(dep)) {
+					const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
+					const graphRef = toBunjaGraphRef(bunjaRef);
+					currentBunja.addRequiredBunjaRef(graphRef);
+					return this.#useBunjaDependencyInFrame(frame, bunjaRef);
+				}
 				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 			}),
 			will: ((dep, scopeValuePairs) => {
 				if (!(dep instanceof Bunja || isBunjaRef(dep))) throw new Error("`bunja.will` can only be used with Bunja.");
 				const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-				currentBunja.addOptionalBunjaRef(toBunjaGraphRef(bunjaRef));
+				const graphRef = toBunjaGraphRef(bunjaRef);
+				currentBunja.addOptionalBunjaRef(graphRef);
 				return () => {
 					if (frameStack[frameStack.length - 1] !== frame) throw new Error("A thunk returned by `bunja.will` can only be called inside the same bunja init function.");
-					return this.#useBunjaDependencyInFrame(frame, bunjaRef, "optional");
+					return this.#useBunjaDependencyInFrame(frame, bunjaRef);
 				};
 			}),
 			effect: ((callback) => {
@@ -270,10 +276,8 @@ var BunjaStore = class BunjaStore {
 		}
 		return scopeInstance.value;
 	}
-	#useBunjaDependencyInFrame(frame, bunjaRef, edge) {
+	#useBunjaDependencyInFrame(frame, bunjaRef) {
 		const graphRef = toBunjaGraphRef(bunjaRef);
-		if (edge === "optional" || graphRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(graphRef);
-		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(graphRef);
 		const resolved = this.#resolveBunjaRef(graphRef, frame.readScope, frame.inProgressBunjas, bunjaRef.seed);
 		frame.activeDependencyIds.add(resolved.instance.id);
 		frame.activeDependencyRecipes.push({
@@ -331,8 +335,9 @@ var BunjaStore = class BunjaStore {
 					return readScope(dep);
 				}
 				if (dep instanceof Bunja || isBunjaRef(dep)) {
-					const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-					return this.#prebakeBunjaDependencyInFrame(frame, toBunjaGraphRef(bunjaRef), "required");
+					const bunjaRef = toBunjaGraphRef(normalizeBunjaRuntimeRef(dep, scopeValuePairs));
+					currentBunja.addRequiredBunjaRef(bunjaRef);
+					return this.#prebakeBunjaRef(bunjaRef, readScope, prebakeContext);
 				}
 				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 			}),
@@ -350,11 +355,6 @@ var BunjaStore = class BunjaStore {
 		};
 		return frame;
 	}
-	#prebakeBunjaDependencyInFrame(frame, bunjaRef, edge) {
-		if (edge === "optional" || bunjaRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(bunjaRef);
-		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(bunjaRef);
-		return this.#prebakeBunjaRef(bunjaRef, frame.readScope, frame.prebakeContext);
-	}
 	#resolveScopeInstanceMap(bunja$1, readScope) {
 		const scopeInstanceMap = /* @__PURE__ */ new Map();
 		this.#ensureRequiredScopeInstances(bunja$1, scopeInstanceMap, readScope);
@@ -485,7 +485,10 @@ var Bunja = class Bunja {
 		const requiredBunjas = this.requiredBunjas;
 		const expandedRequiredBunjas = toposortRequiredBunjas(requiredBunjas);
 		const requiredScopeSet = /* @__PURE__ */ new Set();
-		for (const bunja$1 of expandedRequiredBunjas) for (const scope of bunja$1.requiredScopes) requiredScopeSet.add(scope);
+		for (const ref of requiredBunjaRefs) {
+			const boundScopes = getBoundScopeSet(ref.scopeValuePairs);
+			for (const scope of ref.bunja.requiredScopes) if (!boundScopes.has(scope)) requiredScopeSet.add(scope);
+		}
 		for (const scope of scopes) requiredScopeSet.add(scope);
 		this.#phase = {
 			baked: true,

package/dist/{bunja-CtHOS4_Q.js → bunja-D0Qa6gsc.js}

@@ -72,8 +72,8 @@ function isBunjaRef(value) {
 function getBoundScopeSet(scopeValuePairs) {
 	return new Set(scopeValuePairs.map(([scope]) => scope));
 }
-function getScopeInstances(scopes, scopeInstanceMap, excludeScopes = /* @__PURE__ */ new Set()) {
-	return scopes.filter((scope) => !excludeScopes.has(scope)).map((scope) => scopeInstanceMap.get(scope));
+function getScopeInstances(scopes, scopeInstanceMap) {
+	return scopes.map((scope) => scopeInstanceMap.get(scope));
 }
 function dedupeScopeInstances(scopeInstances) {
 	const seen = /* @__PURE__ */ new Set();
@@ -126,7 +126,7 @@ var BunjaStore = class BunjaStore {
 	}
 	get(bunjaOrRef, readScope) {
 		const bunjaRef = normalizeBunjaRuntimeRef(bunjaOrRef);
-		const resolved = this.#resolveBunjaRef(toBunjaGraphRef(bunjaRef), readScope, /* @__PURE__ */ new Set(), bunjaRef.seed);
+		const resolved = this.#resolveBunjaRef(toBunjaGraphRef(bunjaRef), readScope, /* @__PURE__ */ new Set(), bunjaRef.seed, true);
 		const result = {
 			value: resolved.value,
 			mount: resolved.mount,
@@ -149,17 +149,17 @@ var BunjaStore = class BunjaStore {
 			requiredScopes: bunjaRef.bunja.requiredScopes
 		};
 	}
-	#resolveBunjaRef(bunjaRef, readScope, inProgressBunjas, seed = bunjaRef.bunja.defaultSeed) {
+	#resolveBunjaRef(bunjaRef, readScope, inProgressBunjas, seed = bunjaRef.bunja.defaultSeed, includeBoundScopeDeps = false) {
 		const { bunja: bunja$1 } = bunjaRef;
 		if (inProgressBunjas.has(bunja$1)) throw new Error("Circular bunja dependency detected.");
 		const resolvedReadScope = bunjaRef.scopeValuePairs.length > 0 ? createReadScopeFn(bunjaRef.scopeValuePairs, readScope) : readScope;
 		inProgressBunjas.add(bunja$1);
 		try {
-			if (!bunja$1.baked) return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed);
+			if (!bunja$1.baked) return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, includeBoundScopeDeps);
 			const scopeInstanceMap = this.#resolveScopeInstanceMap(bunja$1, resolvedReadScope);
 			const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
 			const scopeInstances = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap);
-			const directDeps = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap, boundScopes);
+			const directDeps = getScopeInstances(includeBoundScopeDeps ? bunja$1.requiredScopes : bunja$1.requiredScopes.filter((scope) => !boundScopes.has(scope)), scopeInstanceMap);
 			const baseId = bunja$1.calcBaseInstanceId(scopeInstanceMap);
 			const bucket = this.#bunjaBuckets.get(baseId);
 			if (bucket) for (const candidateId of Array.from(bucket)) {
@@ -174,12 +174,12 @@ var BunjaStore = class BunjaStore {
 				if (!instance) continue;
 				return this.#toResolvedBunja(instance, scopeInstances, directDeps, activeDeps.deps);
 			}
-			return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, scopeInstanceMap);
+			return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, includeBoundScopeDeps, scopeInstanceMap);
 		} finally {
 			inProgressBunjas.delete(bunja$1);
 		}
 	}
-	#createResolvedBunja(bunjaRef, readScope, inProgressBunjas, seed, initialScopeInstanceMap = /* @__PURE__ */ new Map()) {
+	#createResolvedBunja(bunjaRef, readScope, inProgressBunjas, seed, includeBoundScopeDeps, initialScopeInstanceMap = /* @__PURE__ */ new Map()) {
 		const { bunja: bunja$1 } = bunjaRef;
 		return this.wrapInstance((dispose) => {
 			let instanceCreated = false;
@@ -196,7 +196,7 @@ var BunjaStore = class BunjaStore {
 				this.#ensureRequiredScopeInstances(bunja$1, frame.scopeInstanceMap, readScope);
 				const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
 				const scopeInstances = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap);
-				const directDeps = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap, boundScopes);
+				const directDeps = getScopeInstances(includeBoundScopeDeps ? bunja$1.requiredScopes : bunja$1.requiredScopes.filter((scope) => !boundScopes.has(scope)), frame.scopeInstanceMap);
 				const baseId = bunja$1.calcBaseInstanceId(frame.scopeInstanceMap);
 				const id = bunja$1.calcInstanceId(frame.scopeInstanceMap, frame.activeDependencyIds);
 				const existing = this.#bunjas[id];
@@ -241,16 +241,22 @@ var BunjaStore = class BunjaStore {
 			activeDependencyDeps: [],
 			use: ((dep, scopeValuePairs) => {
 				if (dep instanceof Scope) return this.#useScopeInFrame(frame, dep);
-				if (dep instanceof Bunja || isBunjaRef(dep)) return this.#useBunjaDependencyInFrame(frame, normalizeBunjaRuntimeRef(dep, scopeValuePairs), "required");
+				if (dep instanceof Bunja || isBunjaRef(dep)) {
+					const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
+					const graphRef = toBunjaGraphRef(bunjaRef);
+					currentBunja.addRequiredBunjaRef(graphRef);
+					return this.#useBunjaDependencyInFrame(frame, bunjaRef);
+				}
 				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 			}),
 			will: ((dep, scopeValuePairs) => {
 				if (!(dep instanceof Bunja || isBunjaRef(dep))) throw new Error("`bunja.will` can only be used with Bunja.");
 				const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-				currentBunja.addOptionalBunjaRef(toBunjaGraphRef(bunjaRef));
+				const graphRef = toBunjaGraphRef(bunjaRef);
+				currentBunja.addOptionalBunjaRef(graphRef);
 				return () => {
 					if (frameStack[frameStack.length - 1] !== frame) throw new Error("A thunk returned by `bunja.will` can only be called inside the same bunja init function.");
-					return this.#useBunjaDependencyInFrame(frame, bunjaRef, "optional");
+					return this.#useBunjaDependencyInFrame(frame, bunjaRef);
 				};
 			}),
 			effect: ((callback) => {
@@ -269,10 +275,8 @@ var BunjaStore = class BunjaStore {
 		}
 		return scopeInstance.value;
 	}
-	#useBunjaDependencyInFrame(frame, bunjaRef, edge) {
+	#useBunjaDependencyInFrame(frame, bunjaRef) {
 		const graphRef = toBunjaGraphRef(bunjaRef);
-		if (edge === "optional" || graphRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(graphRef);
-		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(graphRef);
 		const resolved = this.#resolveBunjaRef(graphRef, frame.readScope, frame.inProgressBunjas, bunjaRef.seed);
 		frame.activeDependencyIds.add(resolved.instance.id);
 		frame.activeDependencyRecipes.push({
@@ -330,8 +334,9 @@ var BunjaStore = class BunjaStore {
 					return readScope(dep);
 				}
 				if (dep instanceof Bunja || isBunjaRef(dep)) {
-					const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
-					return this.#prebakeBunjaDependencyInFrame(frame, toBunjaGraphRef(bunjaRef), "required");
+					const bunjaRef = toBunjaGraphRef(normalizeBunjaRuntimeRef(dep, scopeValuePairs));
+					currentBunja.addRequiredBunjaRef(bunjaRef);
+					return this.#prebakeBunjaRef(bunjaRef, readScope, prebakeContext);
 				}
 				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 			}),
@@ -349,11 +354,6 @@ var BunjaStore = class BunjaStore {
 		};
 		return frame;
 	}
-	#prebakeBunjaDependencyInFrame(frame, bunjaRef, edge) {
-		if (edge === "optional" || bunjaRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(bunjaRef);
-		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(bunjaRef);
-		return this.#prebakeBunjaRef(bunjaRef, frame.readScope, frame.prebakeContext);
-	}
 	#resolveScopeInstanceMap(bunja$1, readScope) {
 		const scopeInstanceMap = /* @__PURE__ */ new Map();
 		this.#ensureRequiredScopeInstances(bunja$1, scopeInstanceMap, readScope);
@@ -484,7 +484,10 @@ var Bunja = class Bunja {
 		const requiredBunjas = this.requiredBunjas;
 		const expandedRequiredBunjas = toposortRequiredBunjas(requiredBunjas);
 		const requiredScopeSet = /* @__PURE__ */ new Set();
-		for (const bunja$1 of expandedRequiredBunjas) for (const scope of bunja$1.requiredScopes) requiredScopeSet.add(scope);
+		for (const ref of requiredBunjaRefs) {
+			const boundScopes = getBoundScopeSet(ref.scopeValuePairs);
+			for (const scope of ref.bunja.requiredScopes) if (!boundScopes.has(scope)) requiredScopeSet.add(scope);
+		}
 		for (const scope of scopes) requiredScopeSet.add(scope);
 		this.#phase = {
 			baked: true,

package/dist/bunja.cjs

@@ -1,4 +1,4 @@
-const require_bunja = require('./bunja-BJSmIdkQ.cjs');
+const require_bunja = require('./bunja-C_hneAUK.cjs');
 
 exports.Bunja = require_bunja.Bunja;
 exports.BunjaStore = require_bunja.BunjaStore;

package/dist/bunja.js

@@ -1,3 +1,3 @@
-import { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createReadScopeFn, createScope, delayUnmount } from "./bunja-CtHOS4_Q.js";
+import { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createReadScopeFn, createScope, delayUnmount } from "./bunja-D0Qa6gsc.js";
 
 export { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createReadScopeFn, createScope, delayUnmount };

package/dist/react.cjs

@@ -2,7 +2,7 @@
 
 
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_bunja = require('./bunja-BJSmIdkQ.cjs');
+const require_bunja = require('./bunja-C_hneAUK.cjs');
 let react = require("react");
 react = require_chunk.__toESM(react);
 

package/dist/react.js

@@ -1,7 +1,7 @@
 "use client";
 
 
-import { createBunjaStore, createReadScopeFn, createScope, delayUnmount } from "./bunja-CtHOS4_Q.js";
+import { createBunjaStore, createReadScopeFn, createScope, delayUnmount } from "./bunja-D0Qa6gsc.js";
 import * as React from "react";
 import { createContext, createElement, useContext, useEffect, useMemo, useState } from "react";
 

package/dist/solid.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_bunja = require('./bunja-BJSmIdkQ.cjs');
+const require_bunja = require('./bunja-C_hneAUK.cjs');
 let solid_js = require("solid-js");
 solid_js = require_chunk.__toESM(solid_js);
 

package/dist/solid.js

@@ -1,4 +1,4 @@
-import { createBunjaStore, createReadScopeFn, createScope } from "./bunja-CtHOS4_Q.js";
+import { createBunjaStore, createReadScopeFn, createScope } from "./bunja-D0Qa6gsc.js";
 import { createComponent, createContext, createEffect, createMemo, createRoot, getOwner, onCleanup, useContext } from "solid-js";
 
 //#region solid.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunja",
   "type": "module",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "description": "State Lifetime Manager",
   "main": "dist/bunja.cjs",
   "module": "dist/bunja.js",

package/test.ts

@@ -207,6 +207,32 @@ Deno.test({
   },
 });
 
+Deno.test({
+  name: "root scope value pairs are included in store.get deps",
+  fn() {
+    const store = createBunjaStore();
+    const myScope = createScope<string>();
+    const myBunja = bunja(() => {
+      const scopeValue = bunja.use(myScope);
+      return { scopeValue };
+    });
+
+    const first = store.get(
+      { bunja: myBunja, with: [myScope.bind("foo")] },
+      readNull,
+    );
+    const second = store.get(
+      { bunja: myBunja, with: [myScope.bind("bar")] },
+      readNull,
+    );
+
+    assertEquals(first.value.scopeValue, "foo");
+    assertEquals(second.value.scopeValue, "bar");
+    assertEquals(first.deps, ["foo"]);
+    assertEquals(second.deps, ["bar"]);
+  },
+});
+
 Deno.test({
   name: "bunja.use can override scope value pairs inside a bunja init",
   fn() {
@@ -272,6 +298,56 @@ Deno.test({
   },
 });
 
+Deno.test({
+  name: "bunja.use with scope value pairs propagates unbound required scopes",
+  fn() {
+    const createGraph = () => {
+      const injectedScope = createScope<string>();
+      const outerScope = createScope<string>();
+      const dependencyBunja = bunja(() => {
+        const injected = bunja.use(injectedScope);
+        const outer = bunja.use(outerScope);
+        return { injected, outer };
+      });
+      const consumerBunja = bunja(() =>
+        bunja.use(dependencyBunja, [injectedScope.bind("injected")])
+      );
+      return { consumerBunja, injectedScope, outerScope };
+    };
+    const readScope = <T>() => "outer" as T;
+
+    const prebakeGraph = createGraph();
+    const { requiredScopes } = createBunjaStore().prebake(
+      prebakeGraph.consumerBunja,
+      readScope,
+    );
+    assertEquals(requiredScopes.length, 1);
+    assertEquals(requiredScopes[0] === prebakeGraph.outerScope, true);
+    assertEquals(
+      requiredScopes.some((scope) => scope === prebakeGraph.injectedScope),
+      false,
+    );
+
+    const getGraph = createGraph();
+    const { value, deps } = createBunjaStore().get(
+      getGraph.consumerBunja,
+      readScope,
+    );
+    const requiredScopes2 = getGraph.consumerBunja.requiredScopes;
+    assertEquals(value, { injected: "injected", outer: "outer" });
+    assertEquals(deps, ["outer"]);
+    assertEquals(requiredScopes2.length, 1);
+    assertEquals(
+      requiredScopes2[0] === getGraph.outerScope,
+      true,
+    );
+    assertEquals(
+      requiredScopes2.some((scope) => scope === getGraph.injectedScope),
+      false,
+    );
+  },
+});
+
 Deno.test({
   name: "seed is used only when creating a bunja instance",
   fn() {
@@ -404,6 +480,29 @@ Deno.test({
   },
 });
 
+Deno.test({
+  name: "bunja.will records optional refs once when thunk is used",
+  fn() {
+    const createConsumer = () => {
+      const dependencyBunja = bunja(() => "dependency");
+      const consumerBunja = bunja(() => {
+        const getDependency = bunja.will(dependencyBunja);
+        return getDependency();
+      });
+      return { consumerBunja };
+    };
+
+    const getGraph = createConsumer();
+    createBunjaStore().get(getGraph.consumerBunja, readNull);
+
+    const prebakeGraph = createConsumer();
+    createBunjaStore().prebake(prebakeGraph.consumerBunja, readNull);
+
+    assertEquals(getGraph.consumerBunja.optionalBunjaRefs.length, 1);
+    assertEquals(prebakeGraph.consumerBunja.optionalBunjaRefs.length, 1);
+  },
+});
+
 Deno.test({
   name: "relatedBunjas includes nested bunja.will dependencies",
   fn() {